CPD Results

The following document contains the results of PMD's CPD 5.0.2.

Duplications

FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java6457
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java32082
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_2(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(1, xla); }
  }

  private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_3(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(2, xla); }
  }

  private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_4(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(3, xla); }
  }

  private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_5(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(4, xla); }
  }

  private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_6(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(5, xla); }
  }

  private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_7(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(6, xla); }
  }

  private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_8(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(7, xla); }
  }

  private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_9(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(8, xla); }
  }

  private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_10(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(9, xla); }
  }

  private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_11(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(10, xla); }
  }

  private boolean jj_2_12(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_12(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(11, xla); }
  }

  private boolean jj_2_13(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_13(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(12, xla); }
  }

  private boolean jj_2_14(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_14(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(13, xla); }
  }

  private boolean jj_2_15(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_15(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(14, xla); }
  }

  private boolean jj_2_16(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_16(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(15, xla); }
  }

  private boolean jj_2_17(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_17(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(16, xla); }
  }

  private boolean jj_2_18(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_18(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(17, xla); }
  }

  private boolean jj_2_19(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_19(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(18, xla); }
  }

  private boolean jj_2_20(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_20(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(19, xla); }
  }

  private boolean jj_2_21(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_21(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(20, xla); }
  }

  private boolean jj_2_22(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_22(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(21, xla); }
  }

  private boolean jj_2_23(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_23(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(22, xla); }
  }

  private boolean jj_2_24(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_24(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(23, xla); }
  }

  private boolean jj_2_25(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_25(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(24, xla); }
  }

  private boolean jj_2_26(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_26(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(25, xla); }
  }

  private boolean jj_2_27(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_27(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(26, xla); }
  }

  private boolean jj_2_28(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_28(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(27, xla); }
  }

  private boolean jj_2_29(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_29(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(28, xla); }
  }

  private boolean jj_2_30(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_30(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(29, xla); }
  }

  private boolean jj_2_31(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_31(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(30, xla); }
  }

  private boolean jj_2_32(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_32(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(31, xla); }
  }

  private boolean jj_2_33(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_33(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(32, xla); }
  }

  private boolean jj_2_34(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_34(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(33, xla); }
  }

  private boolean jj_2_35(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_35(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(34, xla); }
  }

  private boolean jj_2_36(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_36(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(35, xla); }
  }

  private boolean jj_2_37(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_37(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(36, xla); }
  }

  private boolean jj_2_38(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_38(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(37, xla); }
  }

  private boolean jj_2_39(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_39(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(38, xla); }
  }

  private boolean jj_2_40(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_40(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(39, xla); }
  }

  private boolean jj_2_41(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_41(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(40, xla); }
  }

  private boolean jj_2_42(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_42(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(41, xla); }
  }

  private boolean jj_2_43(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_43(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(42, xla); }
  }

  private boolean jj_2_44(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_44(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(43, xla); }
  }

  private boolean jj_2_45(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_45(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(44, xla); }
  }

  private boolean jj_2_46(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_46(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(45, xla); }
  }

  private boolean jj_2_47(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_47(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(46, xla); }
  }

  private boolean jj_2_48(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_48(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(47, xla); }
  }

  private boolean jj_2_49(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_49(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(48, xla); }
  }

  private boolean jj_2_50(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_50(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(49, xla); }
  }

  private boolean jj_2_51(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_51(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(50, xla); }
  }

  private boolean jj_2_52(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_52(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(51, xla); }
  }

  private boolean jj_2_53(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_53(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(52, xla); }
  }

  private boolean jj_2_54(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_54(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(53, xla); }
  }

  private boolean jj_2_55(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_55(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(54, xla); }
  }

  private boolean jj_2_56(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_56(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(55, xla); }
  }

  private boolean jj_2_57(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_57(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(56, xla); }
  }

  private boolean jj_2_58(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_58(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(57, xla); }
  }

  private boolean jj_2_59(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_59(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(58, xla); }
  }

  private boolean jj_2_60(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_60(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(59, xla); }
  }

  private boolean jj_2_61(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_61(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(60, xla); }
  }

  private boolean jj_2_62(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_62(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(61, xla); }
  }

  private boolean jj_2_63(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_63(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(62, xla); }
  }

  private boolean jj_2_64(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_64(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(63, xla); }
  }

  private boolean jj_2_65(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_65(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(64, xla); }
  }

  private boolean jj_2_66(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_66(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(65, xla); }
  }

  private boolean jj_2_67(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_67(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(66, xla); }
  }

  private boolean jj_2_68(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_68(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(67, xla); }
  }

  private boolean jj_2_69(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_69(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(68, xla); }
  }

  private boolean jj_2_70(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_70(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(69, xla); }
  }

  private boolean jj_2_71(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_71(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(70, xla); }
  }

  private boolean jj_2_72(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_72(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(71, xla); }
  }

  private boolean jj_3R_217() {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserVisitorAdapter.java10
net/sourceforge/pmd/lang/java/rule/AbstractJavaRule.java71
    }

    public Object visit(ASTExtendsList node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTImplementsList node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeParameters node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMemberSelector node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeParameter node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeBound node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTClassOrInterfaceBody node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTClassOrInterfaceBodyDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTEnumBody node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTEnumConstant node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTReferenceType node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTClassOrInterfaceType node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeArguments node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeArgument node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTWildcardBounds node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAnnotation node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTNormalAnnotation node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMarkerAnnotation node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTSingleMemberAnnotation node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMemberValuePairs node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMemberValuePair node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMemberValue node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMemberValueArrayInitializer node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAnnotationTypeDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAnnotationTypeBody node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAnnotationTypeMemberDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }
    public Object visit(ASTAnnotationMethodDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTDefaultValue node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTRUNSIGNEDSHIFT node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTRSIGNEDSHIFT node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTCompilationUnit node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTEnumDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAssertStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPackageDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTImportDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTypeDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTFieldDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTVariableDeclarator node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTVariableDeclaratorId node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTVariableInitializer node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTArrayInitializer node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMethodDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMethodDeclarator node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTFormalParameters node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTFormalParameter node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTConstructorDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTExplicitConstructorInvocation node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTInitializer node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTType node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPrimitiveType node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTResultType node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTName node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTNameList node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAssignmentOperator node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTConditionalExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTConditionalOrExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTConditionalAndExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTInclusiveOrExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTExclusiveOrExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAndExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTEqualityExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTInstanceOfExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTRelationalExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTShiftExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAdditiveExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTMultiplicativeExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTUnaryExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPreIncrementExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPreDecrementExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTUnaryExpressionNotPlusMinus node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPostfixExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTCastExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPrimaryExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPrimaryPrefix node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTPrimarySuffix node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTLiteral node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTBooleanLiteral node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTNullLiteral node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTArguments node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTArgumentList node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTAllocationExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTArrayDimsAndInits node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTLabeledStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTBlock node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTBlockStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTLocalVariableDeclaration node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTEmptyStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTStatementExpression node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTSwitchStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTSwitchLabel node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTIfStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTWhileStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTDoStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTForStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTForInit node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTStatementExpressionList node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTForUpdate node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTBreakStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTContinueStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTReturnStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTThrowStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTSynchronizedStatement node, Object data) {
        return visit((JavaNode) node, data);
    }

    public Object visit(ASTTryStatement node, Object data) {
        return visit((JavaNode) node, data);
    }
    public Object visit(ASTResourceSpecification node, Object data) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java65
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java149
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTObjectNameDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTFormalParameter node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTMethodDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTMethodDeclarator node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTFormalParameters node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTVariableOrConstantDeclarator node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTVariableOrConstantDeclaratorId node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTVariableOrConstantInitializer node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDatatype node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCompilationDataType node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCollectionTypeName node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTScalarDataTypeName node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDateTimeLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTExceptionHandler node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSkip2NextTerminator node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSkip2NextOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSkipPastNextOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSkip2NextTokenOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSkipPastNextTokenOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTRead2NextOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTReadPastNextOccurrence node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSqlStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTWrappedObject node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTUnlabelledStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTLabelledStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCaseStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCaseWhenClause node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTElseClause node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTElsifClause node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTLoopStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTForStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTWhileStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTIfStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTForIndex node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTForAllIndex node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTForAllStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTGotoStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTReturnStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTContinueStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTExitStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTRaiseStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCloseStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTOpenStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTFetchStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTEmbeddedSqlStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPipelineStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTConditionalCompilationStatement node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSubTypeDefinition node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTFieldDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCollectionTypeDefinition node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCollectionDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTObjectDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCallSpecTail node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCursorUnit node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCursorSpecification node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCursorBody node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCompilationExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAssignment node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCaseExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTLikeExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTrimExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTObjectExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTConditionalOrExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTConditionalAndExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTEqualityExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTRelationalExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAdditiveExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTStringExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTMultiplicativeExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTUnaryExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTUnaryExpressionNotPlusMinus node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPrimaryExpression node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPrimaryPrefix node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPrimarySuffix node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTStringLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTBooleanLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTNullLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTMultiSetCondition node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTNumericLiteral node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTLabel node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTName node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTQualifiedName node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTArguments node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTArgumentList node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTArgument node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTVariableOrConstantDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDatatypeDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPragma node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTInlinePragma node, Object data) {
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserVisitorAdapter.java5
net/sourceforge/pmd/lang/vm/rule/AbstractVmRule.java81
    @Override
    public Object visit(final VmNode node, final Object data) {
        node.childrenAccept(this, data);
        return null;
    }

    @Override
    public Object visit(final ASTprocess node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTEscapedDirective node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTEscape node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTComment node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTTextblock node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTFloatingPointLiteral node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTIntegerLiteral node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTStringLiteral node, final Object data) {
        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTIdentifier node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTWord node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTDirective node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTBlock node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTMap node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTObjectArray node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTIntegerRange node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTMethod node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTIndex node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTReference node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTTrue node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTFalse node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTText node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTForeachStatement node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTIfStatement node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTElseStatement node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTElseIfStatement node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTSetDirective node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTExpression node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTAssignment node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTOrNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTAndNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTEQNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTNENode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTLTNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTGTNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTLENode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTGENode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTAddNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTSubtractNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTMulNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTDivNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTModNode node, final Object data) {

        return visit((VmNode) node, data);
    }

    @Override
    public Object visit(final ASTNotNode node, final Object data) {

        return visit((VmNode) node, data);
    }

}
FileLine
net/sourceforge/pmd/lang/ecmascript/ast/EcmascriptParserVisitorAdapter.java8
net/sourceforge/pmd/lang/ecmascript/rule/AbstractEcmascriptRule.java104
    public Object visit(EcmascriptNode node, Object data) {
	node.childrenAccept(this, data);
	return null;
    }

    public Object visit(ASTArrayComprehension node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTArrayComprehensionLoop node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTArrayLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTAssignment node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTAstRoot node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTBlock node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTBreakStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTCatchClause node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTComment node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTConditionalExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTContinueStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTDoLoop node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTElementGet node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTEmptyExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTExpressionStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTForInLoop node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTForLoop node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTFunctionCall node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTFunctionNode node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTIfStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTInfixExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTKeywordLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTLabel node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTLabeledStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTLetNode node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTName node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTNewExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTNumberLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTObjectLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTObjectProperty node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTParenthesizedExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTPropertyGet node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTRegExpLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTReturnStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTScope node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTStringLiteral node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTSwitchCase node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTSwitchStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTThrowStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTTryStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTUnaryExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTVariableDeclaration node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTVariableInitializer node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTWhileLoop node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTWithStatement node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTXmlDotQuery node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTXmlExpression node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTXmlMemberGet node, Object data) {
	return visit((EcmascriptNode) node, data);
    }

    public Object visit(ASTXmlString node, Object data) {
	return visit((EcmascriptNode) node, data);
    }
}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2891
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4328
        }
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          DeclarativeUnit();
          break;
        case CC_ERROR:
          jj_consume_token(CC_ERROR);
          Expression();
          jj_consume_token(CC_END);
          break;
        default:
          jj_la1[35] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20859
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26349
        label_66:
        while (true) {
          jj_consume_token(6);
          switch (jj_nt.kind) {
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case SERIALLY_REUSABLE:
          case RESTRICT_REFERENCES:
          case EXCEPTION_INIT:
          case AUTONOMOUS_TRANSACTION:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ALL:
          case ALTER:
          case AND:
          case ANY:
          case ARRAY:
          case AS:
          case ASC:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case AVG:
          case BETWEEN:
          case BINARY_INTEGER:
          case BODY:
          case BOOLEAN:
          case BULK:
          case BY:
          case BYTE:
          case CASCADE:
          case CASE:
          case CHAR:
          case CHAR_BASE:
          case CHECK:
          case CLOSE:
          case CLUSTER:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case COMPRESS:
          case CONNECT:
          case CONSTANT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CREATE:
          case CURRENT:
          case CURRVAL:
          case CURSOR:
          case DATA:
          case DATE:
          case DAY:
          case DECLARE:
          case DECIMAL:
          case _DEFAULT:
          case DELETE:
          case DESC:
          case DISABLE:
          case DISTINCT:
          case DO:
          case DROP:
          case EDITIONABLE:
          case ELEMENT:
          case ELSE:
          case ELSIF:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTION:
          case EXCEPTIONS:
          case EXCLUSIVE:
          case EXECUTE:
          case EXISTS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FETCH:
          case FINAL:
          case FLOAT:
          case FOR:
          case FORALL:
          case FORCE:
          case FROM:
          case FUNCTION:
          case GLOBAL:
          case GOTO:
          case GROUP:
          case HASH:
          case HAVING:
          case HEAP:
          case HOUR:
          case IF:
          case IMMEDIATE:
          case IN:
          case INDEX:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSERT:
          case INSTANTIABLE:
          case INTEGER:
          case INTERFACE:
          case INTERSECT:
          case INTERVAL:
          case INTO:
          case INVALIDATE:
          case IS:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIKE:
          case LIMIT:
          case LIMITED:
          case LOCK:
          case LONG:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUS:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MODE:
          case MONTH:
          case NATURAL:
          case NATURALN:
          case NEW:
          case NEXTVAL:
          case NO:
          case NOCOPY:
          case NONEDITIONABLE:
          case NOT:
          case NOWAIT:
          case NULL:
          case NULLIF:
          case NUMBER:
          case BFILE_BASE:
          case BLOB_BASE:
          case CLOB_BASE:
          case DATE_BASE:
          case NUMBER_BASE:
          case OBJECT:
          case OCIROWID:
          case OF:
          case OID:
          case ON:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case OPTION:
          case OR:
          case ORDER:
          case ORGANIZATION:
          case OTHERS:
          case OUT:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PCTFREE:
          case PLS_INTEGER:
          case POSITIVE:
          case POSITIVEN:
          case PRESERVE:
          case PRIOR:
          case PROMPT:
          case PRIVATE:
          case PROCEDURE:
          case PUBLIC:
          case RAISE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case ROWTYPE:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELECT:
          case SELF:
          case SEPARATE:
          case SET:
          case SHARE:
          case SMALLINT:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case START:
          case STATIC:
          case STDDEV:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SUM:
          case SYNONYM:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TABLE:
          case TEMPORARY:
          case THEN:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TO:
          case TRANSACTION:
          case TRIGGER:
          case TRUE:
          case TYPE:
          case UI:
          case UNDER:
          case USING:
          case WHILE:
          case YES:
          case SHOW:
          case A:
          case UPDATE:
          case VARCHAR:
          case VARCHAR2:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case SIGNTYPE:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case WITH:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            ID();
            break;
          case STRING_LITERAL:
            StringLiteral();
            break;
          default:
            jj_la1[268] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3978
      label_8:
      while (true) {
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ;
          break;
        default:
          jj_la1[34] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25376
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25738
        if (jj_2_70(2)) {
          TypeMethod();
        } else {
          switch (jj_nt.kind) {
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case SERIALLY_REUSABLE:
          case RESTRICT_REFERENCES:
          case EXCEPTION_INIT:
          case AUTONOMOUS_TRANSACTION:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ALL:
          case ALTER:
          case AND:
          case ANY:
          case ARRAY:
          case AS:
          case ASC:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case AVG:
          case BETWEEN:
          case BINARY_INTEGER:
          case BODY:
          case BOOLEAN:
          case BULK:
          case BY:
          case BYTE:
          case CASCADE:
          case CASE:
          case CHAR:
          case CHAR_BASE:
          case CHECK:
          case CLOSE:
          case CLUSTER:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case COMPRESS:
          case CONNECT:
          case CONSTANT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CREATE:
          case CURRENT:
          case CURRVAL:
          case CURSOR:
          case DATA:
          case DATE:
          case DAY:
          case DECLARE:
          case DECIMAL:
          case _DEFAULT:
          case DELETE:
          case DESC:
          case DISABLE:
          case DISTINCT:
          case DO:
          case DROP:
          case EDITIONABLE:
          case ELEMENT:
          case ELSE:
          case ELSIF:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTION:
          case EXCEPTIONS:
          case EXCLUSIVE:
          case EXECUTE:
          case EXISTS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FETCH:
          case FINAL:
          case FLOAT:
          case FOR:
          case FORALL:
          case FORCE:
          case FROM:
          case FUNCTION:
          case GLOBAL:
          case GOTO:
          case GROUP:
          case HASH:
          case HAVING:
          case HEAP:
          case HOUR:
          case IF:
          case IMMEDIATE:
          case IN:
          case INDEX:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSERT:
          case INSTANTIABLE:
          case INTEGER:
          case INTERFACE:
          case INTERSECT:
          case INTERVAL:
          case INTO:
          case INVALIDATE:
          case IS:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIKE:
          case LIMIT:
          case LIMITED:
          case LOCK:
          case LONG:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUS:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MODE:
          case MONTH:
          case NATURAL:
          case NATURALN:
          case NEW:
          case NEXTVAL:
          case NO:
          case NOCOPY:
          case NONEDITIONABLE:
          case NOT:
          case NOWAIT:
          case NULL:
          case NULLIF:
          case NUMBER:
          case BFILE_BASE:
          case BLOB_BASE:
          case CLOB_BASE:
          case DATE_BASE:
          case NUMBER_BASE:
          case OBJECT:
          case OCIROWID:
          case OF:
          case OID:
          case ON:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case OPTION:
          case OR:
          case ORDER:
          case ORGANIZATION:
          case OTHERS:
          case OUT:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PCTFREE:
          case PLS_INTEGER:
          case POSITIVE:
          case POSITIVEN:
          case PRESERVE:
          case PRIOR:
          case PROMPT:
          case PRIVATE:
          case PROCEDURE:
          case PUBLIC:
          case RAISE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case ROWTYPE:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELECT:
          case SELF:
          case SEPARATE:
          case SET:
          case SHARE:
          case SMALLINT:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case START:
          case STATIC:
          case STDDEV:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SUM:
          case SYNONYM:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TABLE:
          case TEMPORARY:
          case THEN:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TO:
          case TRANSACTION:
          case TRIGGER:
          case TRUE:
          case TYPE:
          case UI:
          case UNDER:
          case USING:
          case WHILE:
          case YES:
          case SHOW:
          case A:
          case UPDATE:
          case VARCHAR:
          case VARCHAR2:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case SIGNTYPE:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case WITH:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            AttributeDeclaration();
            break;
          default:
            jj_la1[376] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5947
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23629
          jj_la1[28] = jj_gen;
          ;
        }
        jj_consume_token(END);
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ID();
          break;
        default:
          jj_la1[29] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24585
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25376
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25738
          if (jj_2_67(2)) {
            TypeMethod();
          } else {
            switch (jj_nt.kind) {
            case REPLACE:
            case DEFINER:
            case CURRENT_USER:
            case SERIALLY_REUSABLE:
            case RESTRICT_REFERENCES:
            case EXCEPTION_INIT:
            case AUTONOMOUS_TRANSACTION:
            case LANGUAGE:
            case INLINE:
            case ADD:
            case AGGREGATE:
            case ALL:
            case ALTER:
            case AND:
            case ANY:
            case ARRAY:
            case AS:
            case ASC:
            case AT:
            case ATTRIBUTE:
            case AUTHID:
            case AVG:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
            case EXTENDS:
            case EXTRACT:
            case FALSE:
            case FETCH:
            case FINAL:
            case FLOAT:
            case FOR:
            case FORALL:
            case FORCE:
            case FROM:
            case FUNCTION:
            case GLOBAL:
            case GOTO:
            case GROUP:
            case HASH:
            case HAVING:
            case HEAP:
            case HOUR:
            case IF:
            case IMMEDIATE:
            case IN:
            case INDEX:
            case INDICES:
            case INDEXTYPE:
            case INDICATOR:
            case INSERT:
            case INSTANTIABLE:
            case INTEGER:
            case INTERFACE:
            case INTERSECT:
            case INTERVAL:
            case INTO:
            case INVALIDATE:
            case IS:
            case ISOLATION:
            case JAVA:
            case LEVEL:
            case LIKE:
            case LIMIT:
            case LIMITED:
            case LOCK:
            case LONG:
            case LOOP:
            case MAP:
            case MAX:
            case MEMBER:
            case MERGE:
            case MIN:
            case MINUS:
            case MINUTE:
            case MLSLABEL:
            case MODIFY:
            case MOD:
            case MODE:
            case MONTH:
            case NATURAL:
            case NATURALN:
            case NEW:
            case NEXTVAL:
            case NO:
            case NOCOPY:
            case NONEDITIONABLE:
            case NOT:
            case NOWAIT:
            case NULL:
            case NULLIF:
            case NUMBER:
            case BFILE_BASE:
            case BLOB_BASE:
            case CLOB_BASE:
            case DATE_BASE:
            case NUMBER_BASE:
            case OBJECT:
            case OCIROWID:
            case OF:
            case OID:
            case ON:
            case OPAQUE:
            case OPEN:
            case OPERATOR:
            case OPTION:
            case OR:
            case ORDER:
            case ORGANIZATION:
            case OTHERS:
            case OUT:
            case OVERRIDING:
            case PACKAGE:
            case PARTITION:
            case PCTFREE:
            case PLS_INTEGER:
            case POSITIVE:
            case POSITIVEN:
            case PRESERVE:
            case PRIOR:
            case PROMPT:
            case PRIVATE:
            case PROCEDURE:
            case PUBLIC:
            case RAISE:
            case RANGE:
            case RAW:
            case REAL:
            case RECORD:
            case REF:
            case RELEASE:
            case RELIES_ON:
            case RENAME:
            case RESULT:
            case RETURN:
            case RETURNING:
            case REVERSE:
            case ROLLBACK:
            case ROW:
            case ROWS:
            case ROWID:
            case ROWNUM:
            case ROWTYPE:
            case SAVE:
            case SAVEPOINT:
            case SECOND:
            case SELECT:
            case SELF:
            case SEPARATE:
            case SET:
            case SHARE:
            case SMALLINT:
            case SPACE:
            case SQL:
            case SQLCODE:
            case SQLERRM:
            case START:
            case STATIC:
            case STDDEV:
            case SUBTYPE:
            case SUBSTITUTABLE:
            case SUCCESSFUL:
            case SUM:
            case SYNONYM:
            case SYSDATE:
            case SYS_REFCURSOR:
            case TABLE:
            case TEMPORARY:
            case THEN:
            case TIME:
            case TIMESTAMP:
            case TIMEZONE_REGION:
            case TIMEZONE_ABBR:
            case TIMEZONE_MINUTE:
            case TIMEZONE_HOUR:
            case TO:
            case TRANSACTION:
            case TRIGGER:
            case TRUE:
            case TYPE:
            case UI:
            case UNDER:
            case USING:
            case WHILE:
            case YES:
            case SHOW:
            case A:
            case UPDATE:
            case VARCHAR:
            case VARCHAR2:
            case DOUBLE:
            case DEC:
            case PRECISION:
            case INT:
            case NUMERIC:
            case SIGNTYPE:
            case NCHAR:
            case NVARCHAR2:
            case STRING:
            case UROWID:
            case VARRAY:
            case VARYING:
            case BFILE:
            case BLOB:
            case CLOB:
            case NCLOB:
            case YEAR:
            case LOCAL:
            case WITH:
            case ZONE:
            case CHARACTER:
            case AFTER:
            case BEFORE:
            case OLD:
            case PARENT:
            case ANALYZE:
            case ASSOCIATE:
            case AUDIT:
            case COMPOUND:
            case DATABASE:
            case CALL:
            case DDL:
            case DISASSOCIATE:
            case EACH:
            case FOLLOWS:
            case LOGOFF:
            case LOGON:
            case NESTED:
            case NOAUDIT:
            case SCHEMA:
            case SERVERERROR:
            case SHUTDOWN:
            case STARTUP:
            case STATEMENT:
            case STATISTICS:
            case SUSPEND:
            case TRUNCATE:
            case WRAPPED:
            case LIBRARY:
            case NAME:
            case STRUCT:
            case CONTEXT:
            case PARAMETERS:
            case LENGTH:
            case TDO:
            case MAXLEN:
            case CHARSETID:
            case CHARSETFORM:
            case ACCEPT:
            case ACCESSIBLE:
            case COPY:
            case DEFINE:
            case DISCONNECT:
            case HOST:
            case PRINT:
            case QUIT:
            case REMARK:
            case UNDEFINE:
            case VARIABLE:
            case WHENEVER:
            case ATTACH:
            case CAST:
            case TREAT:
            case TRIM:
            case LEFT:
            case RIGHT:
            case BOTH:
            case EMPTY:
            case MULTISET:
            case SUBMULTISET:
            case LEADING:
            case TRAILING:
            case CHAR_CS:
            case NCHAR_CS:
            case DBTIMEZONE:
            case SESSIONTIMEZONE:
            case AUTHENTICATED:
            case LINK:
            case SHARED:
            case DIRECTORY:
            case USER:
            case IDENTIFIER:
            case QUOTED_LITERAL:
            case SQLDATA_CLASS:
            case CUSTOMDATUM_CLASS:
            case ORADATA_CLASS:
            case JAVA_INTERFACE_CLASS:
              AttributeDeclaration();
              break;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1690
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23631
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28393
        }
        jj_consume_token(END);
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ID();
          break;
        default:
          jj_la1[29] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28394
        jj_consume_token(END);
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ID();
          break;
        default:
          jj_la1[18] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28395
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ID();
          break;
        default:
          jj_la1[18] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4329
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28394
        jj_consume_token(END);
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ID();
          break;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24586
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25377
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25739
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27080
            TypeMethod();
          } else {
            switch (jj_nt.kind) {
            case REPLACE:
            case DEFINER:
            case CURRENT_USER:
            case SERIALLY_REUSABLE:
            case RESTRICT_REFERENCES:
            case EXCEPTION_INIT:
            case AUTONOMOUS_TRANSACTION:
            case LANGUAGE:
            case INLINE:
            case ADD:
            case AGGREGATE:
            case ALL:
            case ALTER:
            case AND:
            case ANY:
            case ARRAY:
            case AS:
            case ASC:
            case AT:
            case ATTRIBUTE:
            case AUTHID:
            case AVG:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
            case EXTENDS:
            case EXTRACT:
            case FALSE:
            case FETCH:
            case FINAL:
            case FLOAT:
            case FOR:
            case FORALL:
            case FORCE:
            case FROM:
            case FUNCTION:
            case GLOBAL:
            case GOTO:
            case GROUP:
            case HASH:
            case HAVING:
            case HEAP:
            case HOUR:
            case IF:
            case IMMEDIATE:
            case IN:
            case INDEX:
            case INDICES:
            case INDEXTYPE:
            case INDICATOR:
            case INSERT:
            case INSTANTIABLE:
            case INTEGER:
            case INTERFACE:
            case INTERSECT:
            case INTERVAL:
            case INTO:
            case INVALIDATE:
            case IS:
            case ISOLATION:
            case JAVA:
            case LEVEL:
            case LIKE:
            case LIMIT:
            case LIMITED:
            case LOCK:
            case LONG:
            case LOOP:
            case MAP:
            case MAX:
            case MEMBER:
            case MERGE:
            case MIN:
            case MINUS:
            case MINUTE:
            case MLSLABEL:
            case MODIFY:
            case MOD:
            case MODE:
            case MONTH:
            case NATURAL:
            case NATURALN:
            case NEW:
            case NEXTVAL:
            case NO:
            case NOCOPY:
            case NONEDITIONABLE:
            case NOT:
            case NOWAIT:
            case NULL:
            case NULLIF:
            case NUMBER:
            case BFILE_BASE:
            case BLOB_BASE:
            case CLOB_BASE:
            case DATE_BASE:
            case NUMBER_BASE:
            case OBJECT:
            case OCIROWID:
            case OF:
            case OID:
            case ON:
            case OPAQUE:
            case OPEN:
            case OPERATOR:
            case OPTION:
            case OR:
            case ORDER:
            case ORGANIZATION:
            case OTHERS:
            case OUT:
            case OVERRIDING:
            case PACKAGE:
            case PARTITION:
            case PCTFREE:
            case PLS_INTEGER:
            case POSITIVE:
            case POSITIVEN:
            case PRESERVE:
            case PRIOR:
            case PROMPT:
            case PRIVATE:
            case PROCEDURE:
            case PUBLIC:
            case RAISE:
            case RANGE:
            case RAW:
            case REAL:
            case RECORD:
            case REF:
            case RELEASE:
            case RELIES_ON:
            case RENAME:
            case RESULT:
            case RETURN:
            case RETURNING:
            case REVERSE:
            case ROLLBACK:
            case ROW:
            case ROWS:
            case ROWID:
            case ROWNUM:
            case ROWTYPE:
            case SAVE:
            case SAVEPOINT:
            case SECOND:
            case SELECT:
            case SELF:
            case SEPARATE:
            case SET:
            case SHARE:
            case SMALLINT:
            case SPACE:
            case SQL:
            case SQLCODE:
            case SQLERRM:
            case START:
            case STATIC:
            case STDDEV:
            case SUBTYPE:
            case SUBSTITUTABLE:
            case SUCCESSFUL:
            case SUM:
            case SYNONYM:
            case SYSDATE:
            case SYS_REFCURSOR:
            case TABLE:
            case TEMPORARY:
            case THEN:
            case TIME:
            case TIMESTAMP:
            case TIMEZONE_REGION:
            case TIMEZONE_ABBR:
            case TIMEZONE_MINUTE:
            case TIMEZONE_HOUR:
            case TO:
            case TRANSACTION:
            case TRIGGER:
            case TRUE:
            case TYPE:
            case UI:
            case UNDER:
            case USING:
            case WHILE:
            case YES:
            case SHOW:
            case A:
            case UPDATE:
            case VARCHAR:
            case VARCHAR2:
            case DOUBLE:
            case DEC:
            case PRECISION:
            case INT:
            case NUMERIC:
            case SIGNTYPE:
            case NCHAR:
            case NVARCHAR2:
            case STRING:
            case UROWID:
            case VARRAY:
            case VARYING:
            case BFILE:
            case BLOB:
            case CLOB:
            case NCLOB:
            case YEAR:
            case LOCAL:
            case WITH:
            case ZONE:
            case CHARACTER:
            case AFTER:
            case BEFORE:
            case OLD:
            case PARENT:
            case ANALYZE:
            case ASSOCIATE:
            case AUDIT:
            case COMPOUND:
            case DATABASE:
            case CALL:
            case DDL:
            case DISASSOCIATE:
            case EACH:
            case FOLLOWS:
            case LOGOFF:
            case LOGON:
            case NESTED:
            case NOAUDIT:
            case SCHEMA:
            case SERVERERROR:
            case SHUTDOWN:
            case STARTUP:
            case STATEMENT:
            case STATISTICS:
            case SUSPEND:
            case TRUNCATE:
            case WRAPPED:
            case LIBRARY:
            case NAME:
            case STRUCT:
            case CONTEXT:
            case PARAMETERS:
            case LENGTH:
            case TDO:
            case MAXLEN:
            case CHARSETID:
            case CHARSETFORM:
            case ACCEPT:
            case ACCESSIBLE:
            case COPY:
            case DEFINE:
            case DISCONNECT:
            case HOST:
            case PRINT:
            case QUIT:
            case REMARK:
            case UNDEFINE:
            case VARIABLE:
            case WHENEVER:
            case ATTACH:
            case CAST:
            case TREAT:
            case TRIM:
            case LEFT:
            case RIGHT:
            case BOTH:
            case EMPTY:
            case MULTISET:
            case SUBMULTISET:
            case LEADING:
            case TRAILING:
            case CHAR_CS:
            case NCHAR_CS:
            case DBTIMEZONE:
            case SESSIONTIMEZONE:
            case AUTHENTICATED:
            case LINK:
            case SHARED:
            case DIRECTORY:
            case USER:
            case IDENTIFIER:
            case QUOTED_LITERAL:
            case SQLDATA_CLASS:
            case CUSTOMDATUM_CLASS:
            case ORADATA_CLASS:
            case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26352
                switch (jj_nt.kind) {
                case REPLACE:
                case DEFINER:
                case CURRENT_USER:
                case SERIALLY_REUSABLE:
                case RESTRICT_REFERENCES:
                case EXCEPTION_INIT:
                case AUTONOMOUS_TRANSACTION:
                case LANGUAGE:
                case INLINE:
                case ADD:
                case AGGREGATE:
                case ALL:
                case ALTER:
                case AND:
                case ANY:
                case ARRAY:
                case AS:
                case ASC:
                case AT:
                case ATTRIBUTE:
                case AUTHID:
                case AVG:
                case BETWEEN:
                case BINARY_INTEGER:
                case BODY:
                case BOOLEAN:
                case BULK:
                case BY:
                case BYTE:
                case CASCADE:
                case CASE:
                case CHAR:
                case CHAR_BASE:
                case CHECK:
                case CLOSE:
                case CLUSTER:
                case COALESCE:
                case COLLECT:
                case COLUMN:
                case COMMENT:
                case COMMIT:
                case COMPRESS:
                case CONNECT:
                case CONSTANT:
                case CONSTRUCTOR:
                case CONTINUE:
                case CONVERT:
                case CREATE:
                case CURRENT:
                case CURRVAL:
                case CURSOR:
                case DATA:
                case DATE:
                case DAY:
                case DECLARE:
                case DECIMAL:
                case _DEFAULT:
                case DELETE:
                case DESC:
                case DISABLE:
                case DISTINCT:
                case DO:
                case DROP:
                case EDITIONABLE:
                case ELEMENT:
                case ELSE:
                case ELSIF:
                case ENABLE:
                case ESCAPE:
                case EXCEPT:
                case EXCEPTION:
                case EXCEPTIONS:
                case EXCLUSIVE:
                case EXECUTE:
                case EXISTS:
                case EXIT:
                case EXTERNAL:
                case EXTENDS:
                case EXTRACT:
                case FALSE:
                case FETCH:
                case FINAL:
                case FLOAT:
                case FOR:
                case FORALL:
                case FORCE:
                case FROM:
                case FUNCTION:
                case GLOBAL:
                case GOTO:
                case GROUP:
                case HASH:
                case HAVING:
                case HEAP:
                case HOUR:
                case IF:
                case IMMEDIATE:
                case IN:
                case INDEX:
                case INDICES:
                case INDEXTYPE:
                case INDICATOR:
                case INSERT:
                case INSTANTIABLE:
                case INTEGER:
                case INTERFACE:
                case INTERSECT:
                case INTERVAL:
                case INTO:
                case INVALIDATE:
                case IS:
                case ISOLATION:
                case JAVA:
                case LEVEL:
                case LIKE:
                case LIMIT:
                case LIMITED:
                case LOCK:
                case LONG:
                case LOOP:
                case MAP:
                case MAX:
                case MEMBER:
                case MERGE:
                case MIN:
                case MINUS:
                case MINUTE:
                case MLSLABEL:
                case MODIFY:
                case MOD:
                case MODE:
                case MONTH:
                case NATURAL:
                case NATURALN:
                case NEW:
                case NEXTVAL:
                case NO:
                case NOCOPY:
                case NONEDITIONABLE:
                case NOT:
                case NOWAIT:
                case NULL:
                case NULLIF:
                case NUMBER:
                case BFILE_BASE:
                case BLOB_BASE:
                case CLOB_BASE:
                case DATE_BASE:
                case NUMBER_BASE:
                case OBJECT:
                case OCIROWID:
                case OF:
                case OID:
                case ON:
                case OPAQUE:
                case OPEN:
                case OPERATOR:
                case OPTION:
                case OR:
                case ORDER:
                case ORGANIZATION:
                case OTHERS:
                case OUT:
                case OVERRIDING:
                case PACKAGE:
                case PARTITION:
                case PCTFREE:
                case PLS_INTEGER:
                case POSITIVE:
                case POSITIVEN:
                case PRESERVE:
                case PRIOR:
                case PROMPT:
                case PRIVATE:
                case PROCEDURE:
                case PUBLIC:
                case RAISE:
                case RANGE:
                case RAW:
                case REAL:
                case RECORD:
                case REF:
                case RELEASE:
                case RELIES_ON:
                case RENAME:
                case RESULT:
                case RETURN:
                case RETURNING:
                case REVERSE:
                case ROLLBACK:
                case ROW:
                case ROWS:
                case ROWID:
                case ROWNUM:
                case ROWTYPE:
                case SAVE:
                case SAVEPOINT:
                case SECOND:
                case SELECT:
                case SELF:
                case SEPARATE:
                case SET:
                case SHARE:
                case SMALLINT:
                case SPACE:
                case SQL:
                case SQLCODE:
                case SQLERRM:
                case START:
                case STATIC:
                case STDDEV:
                case SUBTYPE:
                case SUBSTITUTABLE:
                case SUCCESSFUL:
                case SUM:
                case SYNONYM:
                case SYSDATE:
                case SYS_REFCURSOR:
                case TABLE:
                case TEMPORARY:
                case THEN:
                case TIME:
                case TIMESTAMP:
                case TIMEZONE_REGION:
                case TIMEZONE_ABBR:
                case TIMEZONE_MINUTE:
                case TIMEZONE_HOUR:
                case TO:
                case TRANSACTION:
                case TRIGGER:
                case TRUE:
                case TYPE:
                case UI:
                case UNDER:
                case USING:
                case WHILE:
                case YES:
                case SHOW:
                case A:
                case UPDATE:
                case VARCHAR:
                case VARCHAR2:
                case DOUBLE:
                case DEC:
                case PRECISION:
                case INT:
                case NUMERIC:
                case SIGNTYPE:
                case NCHAR:
                case NVARCHAR2:
                case STRING:
                case UROWID:
                case VARRAY:
                case VARYING:
                case BFILE:
                case BLOB:
                case CLOB:
                case NCLOB:
                case YEAR:
                case LOCAL:
                case WITH:
                case ZONE:
                case CHARACTER:
                case AFTER:
                case BEFORE:
                case OLD:
                case PARENT:
                case ANALYZE:
                case ASSOCIATE:
                case AUDIT:
                case COMPOUND:
                case DATABASE:
                case CALL:
                case DDL:
                case DISASSOCIATE:
                case EACH:
                case FOLLOWS:
                case LOGOFF:
                case LOGON:
                case NESTED:
                case NOAUDIT:
                case SCHEMA:
                case SERVERERROR:
                case SHUTDOWN:
                case STARTUP:
                case STATEMENT:
                case STATISTICS:
                case SUSPEND:
                case TRUNCATE:
                case WRAPPED:
                case LIBRARY:
                case NAME:
                case STRUCT:
                case CONTEXT:
                case PARAMETERS:
                case LENGTH:
                case TDO:
                case MAXLEN:
                case CHARSETID:
                case CHARSETFORM:
                case ACCEPT:
                case ACCESSIBLE:
                case COPY:
                case DEFINE:
                case DISCONNECT:
                case HOST:
                case PRINT:
                case QUIT:
                case REMARK:
                case UNDEFINE:
                case VARIABLE:
                case WHENEVER:
                case ATTACH:
                case CAST:
                case TREAT:
                case TRIM:
                case LEFT:
                case RIGHT:
                case BOTH:
                case EMPTY:
                case MULTISET:
                case SUBMULTISET:
                case LEADING:
                case TRAILING:
                case CHAR_CS:
                case NCHAR_CS:
                case DBTIMEZONE:
                case SESSIONTIMEZONE:
                case AUTHENTICATED:
                case LINK:
                case SHARED:
                case DIRECTORY:
                case USER:
                case IDENTIFIER:
                case QUOTED_LITERAL:
                case SQLDATA_CLASS:
                case CUSTOMDATUM_CLASS:
                case ORADATA_CLASS:
                case JAVA_INTERFACE_CLASS:
                  ID();
                  break;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6872
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28394
        jj_consume_token(END);
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25741
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28395
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6873
                switch (jj_nt.kind) {
                case REPLACE:
                case DEFINER:
                case CURRENT_USER:
                case SERIALLY_REUSABLE:
                case RESTRICT_REFERENCES:
                case EXCEPTION_INIT:
                case AUTONOMOUS_TRANSACTION:
                case LANGUAGE:
                case INLINE:
                case ADD:
                case AGGREGATE:
                case ALL:
                case ALTER:
                case AND:
                case ANY:
                case ARRAY:
                case AS:
                case ASC:
                case AT:
                case ATTRIBUTE:
                case AUTHID:
                case AVG:
                case BETWEEN:
                case BINARY_INTEGER:
                case BODY:
                case BOOLEAN:
                case BULK:
                case BY:
                case BYTE:
                case CASCADE:
                case CASE:
                case CHAR:
                case CHAR_BASE:
                case CHECK:
                case CLOSE:
                case CLUSTER:
                case COALESCE:
                case COLLECT:
                case COLUMN:
                case COMMENT:
                case COMMIT:
                case COMPRESS:
                case CONNECT:
                case CONSTANT:
                case CONSTRUCTOR:
                case CONTINUE:
                case CONVERT:
                case CREATE:
                case CURRENT:
                case CURRVAL:
                case CURSOR:
                case DATA:
                case DATE:
                case DAY:
                case DECLARE:
                case DECIMAL:
                case _DEFAULT:
                case DELETE:
                case DESC:
                case DISABLE:
                case DISTINCT:
                case DO:
                case DROP:
                case EDITIONABLE:
                case ELEMENT:
                case ELSE:
                case ELSIF:
                case ENABLE:
                case ESCAPE:
                case EXCEPT:
                case EXCEPTION:
                case EXCEPTIONS:
                case EXCLUSIVE:
                case EXECUTE:
                case EXISTS:
                case EXIT:
                case EXTERNAL:
                case EXTENDS:
                case EXTRACT:
                case FALSE:
                case FETCH:
                case FINAL:
                case FLOAT:
                case FOR:
                case FORALL:
                case FORCE:
                case FROM:
                case FUNCTION:
                case GLOBAL:
                case GOTO:
                case GROUP:
                case HASH:
                case HAVING:
                case HEAP:
                case HOUR:
                case IF:
                case IMMEDIATE:
                case IN:
                case INDEX:
                case INDICES:
                case INDEXTYPE:
                case INDICATOR:
                case INSERT:
                case INSTANTIABLE:
                case INTEGER:
                case INTERFACE:
                case INTERSECT:
                case INTERVAL:
                case INTO:
                case INVALIDATE:
                case IS:
                case ISOLATION:
                case JAVA:
                case LEVEL:
                case LIKE:
                case LIMIT:
                case LIMITED:
                case LOCK:
                case LONG:
                case LOOP:
                case MAP:
                case MAX:
                case MEMBER:
                case MERGE:
                case MIN:
                case MINUS:
                case MINUTE:
                case MLSLABEL:
                case MODIFY:
                case MOD:
                case MODE:
                case MONTH:
                case NATURAL:
                case NATURALN:
                case NEW:
                case NEXTVAL:
                case NO:
                case NOCOPY:
                case NONEDITIONABLE:
                case NOT:
                case NOWAIT:
                case NULL:
                case NULLIF:
                case NUMBER:
                case BFILE_BASE:
                case BLOB_BASE:
                case CLOB_BASE:
                case DATE_BASE:
                case NUMBER_BASE:
                case OBJECT:
                case OCIROWID:
                case OF:
                case OID:
                case ON:
                case OPAQUE:
                case OPEN:
                case OPERATOR:
                case OPTION:
                case OR:
                case ORDER:
                case ORGANIZATION:
                case OTHERS:
                case OUT:
                case OVERRIDING:
                case PACKAGE:
                case PARTITION:
                case PCTFREE:
                case PLS_INTEGER:
                case POSITIVE:
                case POSITIVEN:
                case PRESERVE:
                case PRIOR:
                case PROMPT:
                case PRIVATE:
                case PROCEDURE:
                case PUBLIC:
                case RAISE:
                case RANGE:
                case RAW:
                case REAL:
                case RECORD:
                case REF:
                case RELEASE:
                case RELIES_ON:
                case RENAME:
                case RESULT:
                case RETURN:
                case RETURNING:
                case REVERSE:
                case ROLLBACK:
                case ROW:
                case ROWS:
                case ROWID:
                case ROWNUM:
                case ROWTYPE:
                case SAVE:
                case SAVEPOINT:
                case SECOND:
                case SELECT:
                case SELF:
                case SEPARATE:
                case SET:
                case SHARE:
                case SMALLINT:
                case SPACE:
                case SQL:
                case SQLCODE:
                case SQLERRM:
                case START:
                case STATIC:
                case STDDEV:
                case SUBTYPE:
                case SUBSTITUTABLE:
                case SUCCESSFUL:
                case SUM:
                case SYNONYM:
                case SYSDATE:
                case SYS_REFCURSOR:
                case TABLE:
                case TEMPORARY:
                case THEN:
                case TIME:
                case TIMESTAMP:
                case TIMEZONE_REGION:
                case TIMEZONE_ABBR:
                case TIMEZONE_MINUTE:
                case TIMEZONE_HOUR:
                case TO:
                case TRANSACTION:
                case TRIGGER:
                case TRUE:
                case TYPE:
                case UI:
                case UNDER:
                case USING:
                case WHILE:
                case YES:
                case SHOW:
                case A:
                case UPDATE:
                case VARCHAR:
                case VARCHAR2:
                case DOUBLE:
                case DEC:
                case PRECISION:
                case INT:
                case NUMERIC:
                case SIGNTYPE:
                case NCHAR:
                case NVARCHAR2:
                case STRING:
                case UROWID:
                case VARRAY:
                case VARYING:
                case BFILE:
                case BLOB:
                case CLOB:
                case NCLOB:
                case YEAR:
                case LOCAL:
                case WITH:
                case ZONE:
                case CHARACTER:
                case AFTER:
                case BEFORE:
                case OLD:
                case PARENT:
                case ANALYZE:
                case ASSOCIATE:
                case AUDIT:
                case COMPOUND:
                case DATABASE:
                case CALL:
                case DDL:
                case DISASSOCIATE:
                case EACH:
                case FOLLOWS:
                case LOGOFF:
                case LOGON:
                case NESTED:
                case NOAUDIT:
                case SCHEMA:
                case SERVERERROR:
                case SHUTDOWN:
                case STARTUP:
                case STATEMENT:
                case STATISTICS:
                case SUSPEND:
                case TRUNCATE:
                case WRAPPED:
                case LIBRARY:
                case NAME:
                case STRUCT:
                case CONTEXT:
                case PARAMETERS:
                case LENGTH:
                case TDO:
                case MAXLEN:
                case CHARSETID:
                case CHARSETFORM:
                case ACCEPT:
                case ACCESSIBLE:
                case COPY:
                case DEFINE:
                case DISCONNECT:
                case HOST:
                case PRINT:
                case QUIT:
                case REMARK:
                case UNDEFINE:
                case VARIABLE:
                case WHENEVER:
                case ATTACH:
                case CAST:
                case TREAT:
                case TRIM:
                case LEFT:
                case RIGHT:
                case BOTH:
                case EMPTY:
                case MULTISET:
                case SUBMULTISET:
                case LEADING:
                case TRAILING:
                case CHAR_CS:
                case NCHAR_CS:
                case DBTIMEZONE:
                case SESSIONTIMEZONE:
                case AUTHENTICATED:
                case LINK:
                case SHARED:
                case DIRECTORY:
                case USER:
                case IDENTIFIER:
                case QUOTED_LITERAL:
                case SQLDATA_CLASS:
                case CUSTOMDATUM_CLASS:
                case ORADATA_CLASS:
                case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2914
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5352
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3978
      label_7:
      while (true) {
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24236
      label_7:
      while (true) {
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3262
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4329
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1693
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4876
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6874
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20863
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23634
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24589
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25380
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28396
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28869
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24236
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28004
      label_7:
      while (true) {
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24238
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28006
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
            case EXTERNAL:
            case EXTENDS:
            case EXTRACT:
            case FALSE:
            case FETCH:
            case FINAL:
            case FLOAT:
            case FOR:
            case FORALL:
            case FORCE:
            case FROM:
            case FUNCTION:
            case GLOBAL:
            case GOTO:
            case GROUP:
            case HASH:
            case HAVING:
            case HEAP:
            case HOUR:
            case IF:
            case IMMEDIATE:
            case IN:
            case INDEX:
            case INDICES:
            case INDEXTYPE:
            case INDICATOR:
            case INSERT:
            case INSTANTIABLE:
            case INTEGER:
            case INTERFACE:
            case INTERSECT:
            case INTERVAL:
            case INTO:
            case INVALIDATE:
            case IS:
            case ISOLATION:
            case JAVA:
            case LEVEL:
            case LIKE:
            case LIMIT:
            case LIMITED:
            case LOCK:
            case LONG:
            case LOOP:
            case MAP:
            case MAX:
            case MEMBER:
            case MERGE:
            case MIN:
            case MINUS:
            case MINUTE:
            case MLSLABEL:
            case MODIFY:
            case MOD:
            case MODE:
            case MONTH:
            case NATURAL:
            case NATURALN:
            case NEW:
            case NEXTVAL:
            case NO:
            case NOCOPY:
            case NONEDITIONABLE:
            case NOT:
            case NOWAIT:
            case NULL:
            case NULLIF:
            case NUMBER:
            case BFILE_BASE:
            case BLOB_BASE:
            case CLOB_BASE:
            case DATE_BASE:
            case NUMBER_BASE:
            case OBJECT:
            case OCIROWID:
            case OF:
            case OID:
            case ON:
            case OPAQUE:
            case OPEN:
            case OPERATOR:
            case OPTION:
            case OR:
            case ORDER:
            case ORGANIZATION:
            case OTHERS:
            case OUT:
            case OVERRIDING:
            case PACKAGE:
            case PARTITION:
            case PCTFREE:
            case PLS_INTEGER:
            case POSITIVE:
            case POSITIVEN:
            case PRAGMA:
            case PRESERVE:
            case PRIOR:
            case PROMPT:
            case PRIVATE:
            case PROCEDURE:
            case PUBLIC:
            case RAISE:
            case RANGE:
            case RAW:
            case REAL:
            case RECORD:
            case REF:
            case RELEASE:
            case RELIES_ON:
            case RENAME:
            case RESULT:
            case RETURN:
            case RETURNING:
            case REVERSE:
            case ROLLBACK:
            case ROW:
            case ROWS:
            case ROWID:
            case ROWNUM:
            case ROWTYPE:
            case SAVE:
            case SAVEPOINT:
            case SECOND:
            case SELECT:
            case SELF:
            case SEPARATE:
            case SET:
            case SHARE:
            case SMALLINT:
            case SPACE:
            case SQL:
            case SQLCODE:
            case SQLERRM:
            case START:
            case STATIC:
            case STDDEV:
            case SUBTYPE:
            case SUBSTITUTABLE:
            case SUCCESSFUL:
            case SUM:
            case SYNONYM:
            case SYSDATE:
            case SYS_REFCURSOR:
            case TABLE:
            case TEMPORARY:
            case THEN:
            case TIME:
            case TIMESTAMP:
            case TIMEZONE_REGION:
            case TIMEZONE_ABBR:
            case TIMEZONE_MINUTE:
            case TIMEZONE_HOUR:
            case TO:
            case TRANSACTION:
            case TRIGGER:
            case TRUE:
            case TYPE:
            case UI:
            case UNDER:
            case USING:
            case WHILE:
            case YES:
            case SHOW:
            case A:
            case UPDATE:
            case VARCHAR:
            case VARCHAR2:
            case DOUBLE:
            case DEC:
            case PRECISION:
            case INT:
            case NUMERIC:
            case SIGNTYPE:
            case NCHAR:
            case NVARCHAR2:
            case STRING:
            case UROWID:
            case VARRAY:
            case VARYING:
            case BFILE:
            case BLOB:
            case CLOB:
            case NCLOB:
            case YEAR:
            case LOCAL:
            case WITH:
            case ZONE:
            case CHARACTER:
            case AFTER:
            case BEFORE:
            case OLD:
            case PARENT:
            case CC_IF:
            case ANALYZE:
            case ASSOCIATE:
            case AUDIT:
            case COMPOUND:
            case DATABASE:
            case CALL:
            case DDL:
            case DISASSOCIATE:
            case EACH:
            case FOLLOWS:
            case LOGOFF:
            case LOGON:
            case NESTED:
            case NOAUDIT:
            case SCHEMA:
            case SERVERERROR:
            case SHUTDOWN:
            case STARTUP:
            case STATEMENT:
            case STATISTICS:
            case SUSPEND:
            case TRUNCATE:
            case WRAPPED:
            case LIBRARY:
            case NAME:
            case STRUCT:
            case CONTEXT:
            case PARAMETERS:
            case LENGTH:
            case TDO:
            case MAXLEN:
            case CHARSETID:
            case CHARSETFORM:
            case ACCEPT:
            case ACCESSIBLE:
            case COPY:
            case DEFINE:
            case DISCONNECT:
            case HOST:
            case PRINT:
            case QUIT:
            case REMARK:
            case UNDEFINE:
            case VARIABLE:
            case WHENEVER:
            case ATTACH:
            case CAST:
            case TREAT:
            case TRIM:
            case LEFT:
            case RIGHT:
            case BOTH:
            case EMPTY:
            case MULTISET:
            case SUBMULTISET:
            case LEADING:
            case TRAILING:
            case CHAR_CS:
            case NCHAR_CS:
            case DBTIMEZONE:
            case SESSIONTIMEZONE:
            case AUTHENTICATED:
            case LINK:
            case SHARED:
            case DIRECTORY:
            case USER:
            case IDENTIFIER:
            case QUOTED_LITERAL:
            case SQLDATA_CLASS:
            case CUSTOMDATUM_CLASS:
            case ORADATA_CLASS:
            case JAVA_INTERFACE_CLASS:
              DeclarativeSection();
              jj_consume_token(BEGIN);
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8420
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8694
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10974
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11274
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11606
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11918
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15239
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27672
        label_22:
        while (true) {
          Statement();
          switch (jj_nt.kind) {
          case 5:
          case 16:
          case 17:
          case 21:
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BEGIN:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CASE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DATE:
          case DAY:
          case DECLARE:
          case DELETE:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXECUTE:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FETCH:
          case FINAL:
          case FOR:
          case FORALL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case GOTO:
          case HASH:
          case HEAP:
          case HOUR:
          case IF:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSERT:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOCK:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NEW_DOT:
          case NO:
          case NONEDITIONABLE:
          case NOT:
          case NULL:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PIPE:
          case PRAGMA:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RAISE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELECT:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case WHILE:
          case YES:
          case SHOW:
          case A:
          case UPDATE:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case WITH:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case CC_IF:
          case CC_ERROR:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case UNSIGNED_NUMERIC_LITERAL:
          case CHARACTER_LITERAL:
          case STRING_LITERAL:
          case QUOTED_LITERAL:
            ;
            break;
          default:
            jj_la1[115] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1410
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5674
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14678
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23356
      label_4:
      while (true) {
        switch (jj_nt.kind) {
        case 5:
        case 16:
        case 17:
        case 21:
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BEGIN:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CASE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DELETE:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXECUTE:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FOR:
        case FORALL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case HASH:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOCK:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NEW_DOT:
        case NO:
        case NONEDITIONABLE:
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PIPE:
        case PRAGMA:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          ;
          break;
        default:
          jj_la1[7] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1412
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10375
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10675
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11277
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11921
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12233
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14962
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23358
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27675
        switch (jj_nt.kind) {
        case 5:
        case 16:
        case 17:
        case 21:
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BEGIN:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CASE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DELETE:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXECUTE:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FOR:
        case FORALL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case HASH:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOCK:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NEW_DOT:
        case NO:
        case NONEDITIONABLE:
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PIPE:
        case PRAGMA:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          ;
          break;
        default:
          jj_la1[7] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java548
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1416
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8701
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10679
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11925
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14966
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15246
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27679
        case 21:
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BEGIN:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CASE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DELETE:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXECUTE:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FOR:
        case FORALL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case HASH:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOCK:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NEW_DOT:
        case NO:
        case NONEDITIONABLE:
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PIPE:
        case PRAGMA:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3284
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5352
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24260
            case BEGIN:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
            case EXTENDS:
            case EXTRACT:
            case FALSE:
            case FETCH:
            case FINAL:
            case FLOAT:
            case FOR:
            case FORALL:
            case FORCE:
            case FROM:
            case FUNCTION:
            case GLOBAL:
            case GOTO:
            case GROUP:
            case HASH:
            case HAVING:
            case HEAP:
            case HOUR:
            case IF:
            case IMMEDIATE:
            case IN:
            case INDEX:
            case INDICES:
            case INDEXTYPE:
            case INDICATOR:
            case INSERT:
            case INSTANTIABLE:
            case INTEGER:
            case INTERFACE:
            case INTERSECT:
            case INTERVAL:
            case INTO:
            case INVALIDATE:
            case IS:
            case ISOLATION:
            case JAVA:
            case LEVEL:
            case LIKE:
            case LIMIT:
            case LIMITED:
            case LOCK:
            case LONG:
            case LOOP:
            case MAP:
            case MAX:
            case MEMBER:
            case MERGE:
            case MIN:
            case MINUS:
            case MINUTE:
            case MLSLABEL:
            case MODIFY:
            case MOD:
            case MODE:
            case MONTH:
            case NATURAL:
            case NATURALN:
            case NEW:
            case NEXTVAL:
            case NO:
            case NOCOPY:
            case NONEDITIONABLE:
            case NOT:
            case NOWAIT:
            case NULL:
            case NULLIF:
            case NUMBER:
            case BFILE_BASE:
            case BLOB_BASE:
            case CLOB_BASE:
            case DATE_BASE:
            case NUMBER_BASE:
            case OBJECT:
            case OCIROWID:
            case OF:
            case OID:
            case ON:
            case OPAQUE:
            case OPEN:
            case OPERATOR:
            case OPTION:
            case OR:
            case ORDER:
            case ORGANIZATION:
            case OTHERS:
            case OUT:
            case OVERRIDING:
            case PACKAGE:
            case PARTITION:
            case PCTFREE:
            case PLS_INTEGER:
            case POSITIVE:
            case POSITIVEN:
            case PRAGMA:
            case PRESERVE:
            case PRIOR:
            case PROMPT:
            case PRIVATE:
            case PROCEDURE:
            case PUBLIC:
            case RAISE:
            case RANGE:
            case RAW:
            case REAL:
            case RECORD:
            case REF:
            case RELEASE:
            case RELIES_ON:
            case RENAME:
            case RESULT:
            case RETURN:
            case RETURNING:
            case REVERSE:
            case ROLLBACK:
            case ROW:
            case ROWS:
            case ROWID:
            case ROWNUM:
            case ROWTYPE:
            case SAVE:
            case SAVEPOINT:
            case SECOND:
            case SELECT:
            case SELF:
            case SEPARATE:
            case SET:
            case SHARE:
            case SMALLINT:
            case SPACE:
            case SQL:
            case SQLCODE:
            case SQLERRM:
            case START:
            case STATIC:
            case STDDEV:
            case SUBTYPE:
            case SUBSTITUTABLE:
            case SUCCESSFUL:
            case SUM:
            case SYNONYM:
            case SYSDATE:
            case SYS_REFCURSOR:
            case TABLE:
            case TEMPORARY:
            case THEN:
            case TIME:
            case TIMESTAMP:
            case TIMEZONE_REGION:
            case TIMEZONE_ABBR:
            case TIMEZONE_MINUTE:
            case TIMEZONE_HOUR:
            case TO:
            case TRANSACTION:
            case TRIGGER:
            case TRUE:
            case TYPE:
            case UI:
            case UNDER:
            case USING:
            case WHILE:
            case YES:
            case SHOW:
            case A:
            case UPDATE:
            case VARCHAR:
            case VARCHAR2:
            case DOUBLE:
            case DEC:
            case PRECISION:
            case INT:
            case NUMERIC:
            case SIGNTYPE:
            case NCHAR:
            case NVARCHAR2:
            case STRING:
            case UROWID:
            case VARRAY:
            case VARYING:
            case BFILE:
            case BLOB:
            case CLOB:
            case NCLOB:
            case YEAR:
            case LOCAL:
            case WITH:
            case ZONE:
            case CHARACTER:
            case AFTER:
            case BEFORE:
            case OLD:
            case PARENT:
            case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28028
            case BEGIN:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
            case EXTENDS:
            case EXTRACT:
            case FALSE:
            case FETCH:
            case FINAL:
            case FLOAT:
            case FOR:
            case FORALL:
            case FORCE:
            case FROM:
            case FUNCTION:
            case GLOBAL:
            case GOTO:
            case GROUP:
            case HASH:
            case HAVING:
            case HEAP:
            case HOUR:
            case IF:
            case IMMEDIATE:
            case IN:
            case INDEX:
            case INDICES:
            case INDEXTYPE:
            case INDICATOR:
            case INSERT:
            case INSTANTIABLE:
            case INTEGER:
            case INTERFACE:
            case INTERSECT:
            case INTERVAL:
            case INTO:
            case INVALIDATE:
            case IS:
            case ISOLATION:
            case JAVA:
            case LEVEL:
            case LIKE:
            case LIMIT:
            case LIMITED:
            case LOCK:
            case LONG:
            case LOOP:
            case MAP:
            case MAX:
            case MEMBER:
            case MERGE:
            case MIN:
            case MINUS:
            case MINUTE:
            case MLSLABEL:
            case MODIFY:
            case MOD:
            case MODE:
            case MONTH:
            case NATURAL:
            case NATURALN:
            case NEW:
            case NEXTVAL:
            case NO:
            case NOCOPY:
            case NONEDITIONABLE:
            case NOT:
            case NOWAIT:
            case NULL:
            case NULLIF:
            case NUMBER:
            case BFILE_BASE:
            case BLOB_BASE:
            case CLOB_BASE:
            case DATE_BASE:
            case NUMBER_BASE:
            case OBJECT:
            case OCIROWID:
            case OF:
            case OID:
            case ON:
            case OPAQUE:
            case OPEN:
            case OPERATOR:
            case OPTION:
            case OR:
            case ORDER:
            case ORGANIZATION:
            case OTHERS:
            case OUT:
            case OVERRIDING:
            case PACKAGE:
            case PARTITION:
            case PCTFREE:
            case PLS_INTEGER:
            case POSITIVE:
            case POSITIVEN:
            case PRAGMA:
            case PRESERVE:
            case PRIOR:
            case PROMPT:
            case PRIVATE:
            case PROCEDURE:
            case PUBLIC:
            case RAISE:
            case RANGE:
            case RAW:
            case REAL:
            case RECORD:
            case REF:
            case RELEASE:
            case RELIES_ON:
            case RENAME:
            case RESULT:
            case RETURN:
            case RETURNING:
            case REVERSE:
            case ROLLBACK:
            case ROW:
            case ROWS:
            case ROWID:
            case ROWNUM:
            case ROWTYPE:
            case SAVE:
            case SAVEPOINT:
            case SECOND:
            case SELECT:
            case SELF:
            case SEPARATE:
            case SET:
            case SHARE:
            case SMALLINT:
            case SPACE:
            case SQL:
            case SQLCODE:
            case SQLERRM:
            case START:
            case STATIC:
            case STDDEV:
            case SUBTYPE:
            case SUBSTITUTABLE:
            case SUCCESSFUL:
            case SUM:
            case SYNONYM:
            case SYSDATE:
            case SYS_REFCURSOR:
            case TABLE:
            case TEMPORARY:
            case THEN:
            case TIME:
            case TIMESTAMP:
            case TIMEZONE_REGION:
            case TIMEZONE_ABBR:
            case TIMEZONE_MINUTE:
            case TIMEZONE_HOUR:
            case TO:
            case TRANSACTION:
            case TRIGGER:
            case TRUE:
            case TYPE:
            case UI:
            case UNDER:
            case USING:
            case WHILE:
            case YES:
            case SHOW:
            case A:
            case UPDATE:
            case VARCHAR:
            case VARCHAR2:
            case DOUBLE:
            case DEC:
            case PRECISION:
            case INT:
            case NUMERIC:
            case SIGNTYPE:
            case NCHAR:
            case NVARCHAR2:
            case STRING:
            case UROWID:
            case VARRAY:
            case VARYING:
            case BFILE:
            case BLOB:
            case CLOB:
            case NCLOB:
            case YEAR:
            case LOCAL:
            case WITH:
            case ZONE:
            case CHARACTER:
            case AFTER:
            case BEFORE:
            case OLD:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14094
      jj_consume_token(CASE);
      switch (jj_nt.kind) {
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
        Expression();
        break;
      default:
        jj_la1[123] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20393
      jj_consume_token(CASE);
      switch (jj_nt.kind) {
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1616
net/sourceforge/pmd/lang/vm/ast/VmParser.java3604
    for (int i = 0; i < 33; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

/** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
        int[] oldentry = (int[])(it.next());
        if (oldentry.length == jj_expentry.length) {
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              continue jj_entries_loop;
            }
          }
          jj_expentries.add(jj_expentry);
          break jj_entries_loop;
        }
      }
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[85];
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18253
        case 17:
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CASE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FINAL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case HASH:
        case HEAP:
        case HOUR:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NEW_DOT:
        case NO:
        case NONEDITIONABLE:
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          simpleNode = ConditionalOrExpression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18535
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
        simpleNode = StringExpression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31313
  ASTID jjtn000 = new ASTID(this, JJTID);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch (jj_nt.kind) {
      case IDENTIFIER:
        jj_consume_token(IDENTIFIER);
        break;
      case QUOTED_LITERAL:
        jj_consume_token(QUOTED_LITERAL);
        break;
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PROCEDURE:
      case RANGE:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
        KEYWORD_UNRESERVED();
        break;
      case REPLACE:
        jj_consume_token(REPLACE);
        break;
      case SERIALLY_REUSABLE:
        jj_consume_token(SERIALLY_REUSABLE);
        break;
      case RESTRICT_REFERENCES:
        jj_consume_token(RESTRICT_REFERENCES);
        break;
      case EXCEPTION_INIT:
        jj_consume_token(EXCEPTION_INIT);
        break;
      case AUTONOMOUS_TRANSACTION:
        jj_consume_token(AUTONOMOUS_TRANSACTION);
        break;
      case ALL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19061
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19374
          simpleNode = ScalarDataTypeName();
                                                                sb.append(simpleNode.getImage());
        } else {
          switch (jj_nt.kind) {
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13524
      jj_consume_token(CONTINUE);
      switch (jj_nt.kind) {
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
        label = UnqualifiedID();
        break;
      default:
        jj_la1[146] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13797
      jj_consume_token(CONTINUE);
      switch (jj_nt.kind) {
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7430
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13525
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13798
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19377
          switch (jj_nt.kind) {
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20395
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22231
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22473
        case DEFINER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DAY:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FINAL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case HASH:
        case HEAP:
        case HOUR:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NO:
        case NONEDITIONABLE:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
          UnqualifiedID();
          jj_consume_token(IDENTIFIED);
          jj_consume_token(BY);
          UnqualifiedID();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22471
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13801
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19380
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22231
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31012
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31313
  ASTID jjtn000 = new ASTID(this, JJTID);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch (jj_nt.kind) {
      case IDENTIFIER:
        jj_consume_token(IDENTIFIER);
        break;
      case QUOTED_LITERAL:
        jj_consume_token(QUOTED_LITERAL);
        break;
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PROCEDURE:
      case RANGE:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
        KEYWORD_UNRESERVED();
        break;
      case REPLACE:
FileLine
net/sourceforge/pmd/lang/java/ast/ParseException.java14
net/sourceforge/pmd/lang/jsp/ast/ParseException.java14
net/sourceforge/pmd/lang/plsql/ast/ParseException.java32
net/sourceforge/pmd/lang/vm/ast/ParseException.java14
public class ParseException extends net.sourceforge.pmd.lang.ast.ParseException {

  /**
   * The version identifier for this Serializable class.
   * Increment only if the <i>serialized</i> form of the
   * class changes.
   */
  private static final long serialVersionUID = 1L;

  /**
   * 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.
   */
  public ParseException(Token currentTokenVal,
                        int[][] expectedTokenSequencesVal,
                        String[] tokenImageVal
                       )
  {
    super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal));
    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();
  }

  /** Constructor with message. */
  public ParseException(String message) {
    super(message);
  }


  /**
   * 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;

  /**
   * 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) the correct error message
   * gets displayed.
   */
  private static String initialise(Token currentToken,
                           int[][] expectedTokenSequences,
                           String[] tokenImage) {
    String eol = System.getProperty("line.separator", "\n");
    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.
   */
  static 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();
   }

}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3339
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24315
        case EXIT:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28083
        case EXIT:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14149
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
        Expression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/symboltable/TypeSet.java16
net/sourceforge/pmd/lang/plsql/symboltable/TypeSet.java16
public class TypeSet {

    /**
     * TODO should Resolver provide a canResolve() and a resolve()?
     * Requiring 2 calls seems clunky... but so does this
     * throwing an exception for flow control...
     */
    public interface Resolver {
	Class<?> resolve(String name) throws ClassNotFoundException;
    }

    public static class ExplicitImportResolver implements Resolver {
	private Set<String> importStmts;

	public ExplicitImportResolver(Set<String> importStmts) {
	    this.importStmts = importStmts;
	}

	public Class<?> resolve(String name) throws ClassNotFoundException {
	    for (String importStmt : importStmts) {
		if (importStmt.endsWith(name)) {
		    return Class.forName(importStmt);
		}
	    }
	    throw new ClassNotFoundException("Type " + name + " not found");
	}
    }

    public static class CurrentPackageResolver implements Resolver {
	private String pkg;

	public CurrentPackageResolver(String pkg) {
	    this.pkg = pkg;
	}

	public Class<?> resolve(String name) throws ClassNotFoundException {
	    return Class.forName(pkg + name);
	}
    }

    // TODO cite the JLS section on implicit imports
    public static class ImplicitImportResolver implements Resolver {
	public Class<?> resolve(String name) throws ClassNotFoundException {
	    return Class.forName("java.lang." + name);
	}
    }

    public static class ImportOnDemandResolver implements Resolver {
	private Set<String> importStmts;

	public ImportOnDemandResolver(Set<String> importStmts) {
	    this.importStmts = importStmts;
	}

	public Class<?> resolve(String name) throws ClassNotFoundException {
	    for (String importStmt : importStmts) {
		if (importStmt.endsWith("*")) {
		    try {
			String importPkg = importStmt.substring(0, importStmt.indexOf('*') - 1);
			return Class.forName(importPkg + '.' + name);
		    } catch (ClassNotFoundException cnfe) {
		    }
		}
	    }
	    throw new ClassNotFoundException("Type " + name + " not found");
	}
    }

    public static class PrimitiveTypeResolver implements Resolver {
	private Map<String, Class<?>> primitiveTypes = new HashMap<String, Class<?>>();

	@SuppressWarnings("PMD.AvoidUsingShortType")
	public PrimitiveTypeResolver() {
	    primitiveTypes.put("int", int.class);
	    primitiveTypes.put("float", float.class);
	    primitiveTypes.put("double", double.class);
	    primitiveTypes.put("long", long.class);
	    primitiveTypes.put("boolean", boolean.class);
	    primitiveTypes.put("byte", byte.class);
	    primitiveTypes.put("short", short.class);
	    primitiveTypes.put("char", char.class);
	}

	public Class<?> resolve(String name) throws ClassNotFoundException {
	    if (!primitiveTypes.containsKey(name)) {
		throw new ClassNotFoundException();
	    }
	    return primitiveTypes.get(name);
	}
    }

    public static class VoidResolver implements Resolver {
	public Class<?> resolve(String name) throws ClassNotFoundException {
	    if (name.equals("void")) {
		return void.class;
	    }
	    throw new ClassNotFoundException();
	}
    }

    public static class FullyQualifiedNameResolver implements Resolver {
	public Class<?> resolve(String name) throws ClassNotFoundException {
	    return Class.forName(name);
	}
    }

    private String pkg;
    private Set<String> imports = new HashSet<String>();
    private List<Resolver> resolvers = new ArrayList<Resolver>();

    public void setASTCompilationUnitPackage(String pkg) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20448
      case IMMEDIATE:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10677
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39955
    for (int i = 0; i < 72; i++) {
    try {
      JJCalls p = jj_2_rtns[i];
      do {
        if (p.gen > jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
            case 1: jj_3_2(); break;
            case 2: jj_3_3(); break;
            case 3: jj_3_4(); break;
            case 4: jj_3_5(); break;
            case 5: jj_3_6(); break;
            case 6: jj_3_7(); break;
            case 7: jj_3_8(); break;
            case 8: jj_3_9(); break;
            case 9: jj_3_10(); break;
            case 10: jj_3_11(); break;
            case 11: jj_3_12(); break;
            case 12: jj_3_13(); break;
            case 13: jj_3_14(); break;
            case 14: jj_3_15(); break;
            case 15: jj_3_16(); break;
            case 16: jj_3_17(); break;
            case 17: jj_3_18(); break;
            case 18: jj_3_19(); break;
            case 19: jj_3_20(); break;
            case 20: jj_3_21(); break;
            case 21: jj_3_22(); break;
            case 22: jj_3_23(); break;
            case 23: jj_3_24(); break;
            case 24: jj_3_25(); break;
            case 25: jj_3_26(); break;
            case 26: jj_3_27(); break;
            case 27: jj_3_28(); break;
            case 28: jj_3_29(); break;
            case 29: jj_3_30(); break;
            case 30: jj_3_31(); break;
            case 31: jj_3_32(); break;
            case 32: jj_3_33(); break;
            case 33: jj_3_34(); break;
            case 34: jj_3_35(); break;
            case 35: jj_3_36(); break;
            case 36: jj_3_37(); break;
            case 37: jj_3_38(); break;
            case 38: jj_3_39(); break;
            case 39: jj_3_40(); break;
            case 40: jj_3_41(); break;
            case 41: jj_3_42(); break;
            case 42: jj_3_43(); break;
            case 43: jj_3_44(); break;
            case 44: jj_3_45(); break;
            case 45: jj_3_46(); break;
            case 46: jj_3_47(); break;
            case 47: jj_3_48(); break;
            case 48: jj_3_49(); break;
            case 49: jj_3_50(); break;
            case 50: jj_3_51(); break;
            case 51: jj_3_52(); break;
            case 52: jj_3_53(); break;
            case 53: jj_3_54(); break;
            case 54: jj_3_55(); break;
            case 55: jj_3_56(); break;
            case 56: jj_3_57(); break;
            case 57: jj_3_58(); break;
            case 58: jj_3_59(); break;
            case 59: jj_3_60(); break;
            case 60: jj_3_61(); break;
            case 61: jj_3_62(); break;
            case 62: jj_3_63(); break;
            case 63: jj_3_64(); break;
            case 64: jj_3_65(); break;
            case 65: jj_3_66(); break;
            case 66: jj_3_67(); break;
            case 67: jj_3_68(); break;
            case 68: jj_3_69(); break;
            case 69: jj_3_70(); break;
            case 70: jj_3_71(); break;
            case 71: jj_3_72(); break;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1781
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1986
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2615
private int jjMoveNfa_8(int startState, int curPos)
{
   int startsAt = 0;
   jjnewStateCnt = 12;
   int i = 1;
   jjstateSet[0] = startState;
   int kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
                  if (curChar == 36)
                  {
                     if (kind > 16)
                        kind = 16;
                     jjCheckNAddTwoStates(9, 10);
                  }
                  else if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 0:
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 1:
                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
                     kind = 19;
                  break;
               case 2:
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 0;
                  break;
               case 6:
                  if (curChar == 36 && kind > 16)
                     kind = 16;
                  break;
               case 8:
                  if (curChar == 36)
                     jjCheckNAddTwoStates(9, 10);
                  break;
               case 10:
                  if (curChar == 33 && kind > 17)
                     kind = 17;
                  break;
               case 11:
                  if (curChar != 36)
                     break;
                  if (kind > 16)
                     kind = 16;
                  jjCheckNAddTwoStates(9, 10);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
                  if (curChar == 92)
                     jjCheckNAddStates(100, 103);
                  break;
               case 1:
                  if (kind > 19)
                     kind = 19;
                  break;
               case 5:
                  if (curChar == 92)
                     jjCheckNAddTwoStates(5, 6);
                  break;
               case 7:
                  if (curChar == 92)
                     jjCheckNAddTwoStates(7, 8);
                  break;
               case 9:
                  if (curChar == 92)
                     jjAddStates(104, 105);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
private final int jjStopStringLiteralDfa_6(int pos, long active0)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1781
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1986
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2615
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5085
private int jjMoveNfa_8(int startState, int curPos)
{
   int startsAt = 0;
   jjnewStateCnt = 12;
   int i = 1;
   jjstateSet[0] = startState;
   int kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
                  if (curChar == 36)
                  {
                     if (kind > 16)
                        kind = 16;
                     jjCheckNAddTwoStates(9, 10);
                  }
                  else if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 0:
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 1:
                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
                     kind = 19;
                  break;
               case 2:
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 0;
                  break;
               case 6:
                  if (curChar == 36 && kind > 16)
                     kind = 16;
                  break;
               case 8:
                  if (curChar == 36)
                     jjCheckNAddTwoStates(9, 10);
                  break;
               case 10:
                  if (curChar == 33 && kind > 17)
                     kind = 17;
                  break;
               case 11:
                  if (curChar != 36)
                     break;
                  if (kind > 16)
                     kind = 16;
                  jjCheckNAddTwoStates(9, 10);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
                  if (curChar == 92)
                     jjCheckNAddStates(100, 103);
                  break;
               case 1:
                  if (kind > 19)
                     kind = 19;
                  break;
               case 5:
                  if (curChar == 92)
                     jjCheckNAddTwoStates(5, 6);
                  break;
               case 7:
                  if (curChar == 92)
                     jjCheckNAddTwoStates(7, 8);
                  break;
               case 9:
                  if (curChar == 92)
                     jjAddStates(104, 105);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19782
      case IMMEDIATE:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java6456
net/sourceforge/pmd/lang/vm/ast/VmParser.java2727
    }
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_2(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(1, xla); }
  }

  private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_3(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(2, xla); }
  }

  private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_4(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(3, xla); }
  }

  private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_5(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(4, xla); }
  }

  private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_6(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(5, xla); }
  }

  private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_7(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(6, xla); }
  }

  private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_8(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(7, xla); }
  }

  private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_9(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(8, xla); }
  }

  private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_10(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(9, xla); }
  }

  private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_11(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(10, xla); }
  }

  private boolean jj_2_12(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_12(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(11, xla); }
  }

  private boolean jj_2_13(int xla) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2156
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3261
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25740
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28005
      while (true) {
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2891
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4328
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4874
        }
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java32082
net/sourceforge/pmd/lang/vm/ast/VmParser.java2728
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_2(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(1, xla); }
  }

  private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_3(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(2, xla); }
  }

  private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_4(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(3, xla); }
  }

  private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_5(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(4, xla); }
  }

  private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_6(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(5, xla); }
  }

  private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_7(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(6, xla); }
  }

  private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_8(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(7, xla); }
  }

  private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_9(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(8, xla); }
  }

  private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_10(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(9, xla); }
  }

  private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_11(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(10, xla); }
  }

  private boolean jj_2_12(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_12(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(11, xla); }
  }

  private boolean jj_2_13(int xla) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3262
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25741
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28395
        switch (jj_nt.kind) {
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2158
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24239
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28007
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28869
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case SERIALLY_REUSABLE:
        case RESTRICT_REFERENCES:
        case EXCEPTION_INIT:
        case AUTONOMOUS_TRANSACTION:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ALL:
        case ALTER:
        case AND:
        case ANY:
        case ARRAY:
        case AS:
        case ASC:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRAGMA:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10062
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12974
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16475
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16874
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20394
      switch (jj_nt.kind) {
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28565
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserVisitorAdapter.java8
net/sourceforge/pmd/lang/jsp/rule/AbstractJspRule.java66
    public Object visit(JspNode node, Object data) {
        node.childrenAccept(this, data);
        return null;
    }

    public Object visit(ASTCompilationUnit node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTContent node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspDirective node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspDirectiveAttribute node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspScriptlet node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspExpression node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspDeclaration node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspComment node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTText node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTUnparsedText node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTElExpression node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTValueBinding node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTCData node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTElement node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTAttribute node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTAttributeValue node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTJspExpressionInAttribute node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTCommentTag node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTDeclaration node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTDoctypeDeclaration node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTDoctypeExternalId node, Object data) {
        return visit((JspNode) node, data);
    }

    public Object visit(ASTHtmlScript node, Object data) {
        return visit((JspNode) node, data);
    }
}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16476
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19729
        case 5:
        case 16:
        case 17:
        case REPLACE:
        case DEFINER:
        case CURRENT_USER:
        case LANGUAGE:
        case INLINE:
        case ADD:
        case AGGREGATE:
        case ARRAY:
        case AT:
        case ATTRIBUTE:
        case AUTHID:
        case BODY:
        case BULK:
        case BYTE:
        case CASCADE:
        case CASE:
        case CLOSE:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CURRENT:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DISABLE:
        case EDITIONABLE:
        case ELEMENT:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTIONS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FINAL:
        case FORCE:
        case FUNCTION:
        case GLOBAL:
        case HASH:
        case HEAP:
        case HOUR:
        case IMMEDIATE:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSTANTIABLE:
        case INTERVAL:
        case INVALIDATE:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIMIT:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MONTH:
        case NATURAL:
        case NEW:
        case NEW_DOT:
        case NO:
        case NONEDITIONABLE:
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20397
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19134
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
        simpleNode = StringExpression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18893
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case UNSIGNED_NUMERIC_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java71
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2625
                     jjCheckNAddStates(0, 2);
                  }
                  else if ((0x1800000000L & l) != 0L)
                     jjCheckNAddTwoStates(30, 36);
                  if (curChar == 60)
                     jjstateSet[jjnewStateCnt++] = 26;
                  else if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 10;
                  else if (curChar == 36)
                     jjstateSet[jjnewStateCnt++] = 0;
                  break;
               case 1:
                  if ((0xffffff7bffffffffL & l) != 0L)
                     jjCheckNAddStates(3, 6);
                  break;
               case 2:
                  if (curChar == 34)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 3:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 4:
                  if (curChar == 34)
                     jjCheckNAddStates(3, 6);
                  break;
               case 5:
                  if (curChar == 39)
                     jjCheckNAddTwoStates(6, 7);
                  break;
               case 6:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(6, 7);
                  break;
               case 7:
                  if (curChar == 39)
                     jjCheckNAddStates(3, 6);
                  break;
               case 11:
                  if ((0xffffff7bffffffffL & l) != 0L)
                     jjCheckNAddStates(7, 10);
                  break;
               case 12:
                  if (curChar == 34)
                     jjCheckNAddTwoStates(13, 14);
                  break;
               case 13:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(13, 14);
                  break;
               case 14:
                  if (curChar == 34)
                     jjCheckNAddStates(7, 10);
                  break;
               case 15:
                  if (curChar == 39)
                     jjCheckNAddTwoStates(16, 17);
                  break;
               case 16:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(16, 17);
                  break;
               case 17:
                  if (curChar == 39)
                     jjCheckNAddStates(7, 10);
                  break;
               case 19:
                  if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 20:
                  if (curChar == 61)
                     jjCheckNAddTwoStates(21, 22);
                  break;
               case 21:
                  if ((0xffffffdfffffffffL & l) != 0L)
                     jjCheckNAddStates(11, 13);
                  break;
               case 22:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 23;
                  break;
               case 23:
                  if ((0xbfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(11, 13);
                  break;
               case 24:
                  if (curChar == 62 && kind > 72)
                     kind = 72;
                  break;
               case 25:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 24;
                  break;
               case 26:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 20;
                  break;
               case 27:
                  if (curChar == 60)
                     jjstateSet[jjnewStateCnt++] = 26;
                  break;
               case 28:
                  if ((0xffffffe3ffffffffL & l) == 0L)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16555
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19136
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          simpleNode = ConditionalOrExpression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16555
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18895
        case NOT:
        case NULL:
        case NULLIF:
        case OBJECT:
        case OID:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case ORGANIZATION:
        case OTHERS:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PRESERVE:
        case PRIVATE:
        case PROCEDURE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java75
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2629
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3574
                  if (curChar == 60)
                     jjstateSet[jjnewStateCnt++] = 26;
                  else if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 10;
                  else if (curChar == 36)
                     jjstateSet[jjnewStateCnt++] = 0;
                  break;
               case 1:
                  if ((0xffffff7bffffffffL & l) != 0L)
                     jjCheckNAddStates(3, 6);
                  break;
               case 2:
                  if (curChar == 34)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 3:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 4:
                  if (curChar == 34)
                     jjCheckNAddStates(3, 6);
                  break;
               case 5:
                  if (curChar == 39)
                     jjCheckNAddTwoStates(6, 7);
                  break;
               case 6:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(6, 7);
                  break;
               case 7:
                  if (curChar == 39)
                     jjCheckNAddStates(3, 6);
                  break;
               case 11:
                  if ((0xffffff7bffffffffL & l) != 0L)
                     jjCheckNAddStates(7, 10);
                  break;
               case 12:
                  if (curChar == 34)
                     jjCheckNAddTwoStates(13, 14);
                  break;
               case 13:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(13, 14);
                  break;
               case 14:
                  if (curChar == 34)
                     jjCheckNAddStates(7, 10);
                  break;
               case 15:
                  if (curChar == 39)
                     jjCheckNAddTwoStates(16, 17);
                  break;
               case 16:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(16, 17);
                  break;
               case 17:
                  if (curChar == 39)
                     jjCheckNAddStates(7, 10);
                  break;
               case 19:
                  if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 20:
                  if (curChar == 61)
                     jjCheckNAddTwoStates(21, 22);
                  break;
               case 21:
                  if ((0xffffffdfffffffffL & l) != 0L)
                     jjCheckNAddStates(11, 13);
                  break;
               case 22:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 23;
                  break;
               case 23:
                  if ((0xbfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(11, 13);
                  break;
               case 24:
                  if (curChar == 62 && kind > 72)
                     kind = 72;
                  break;
               case 25:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 24;
                  break;
               case 26:
                  if (curChar == 37)
                     jjstateSet[jjnewStateCnt++] = 20;
                  break;
               case 27:
                  if (curChar == 60)
                     jjstateSet[jjnewStateCnt++] = 26;
                  break;
               case 28:
                  if ((0xffffffe3ffffffffL & l) == 0L)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4897
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23655
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25401
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25763
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28890
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16580
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17392
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18355
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18920
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19161
        case RESULT:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JJTJavaParserState.java14
net/sourceforge/pmd/lang/jsp/ast/JJTJspParserState.java14
net/sourceforge/pmd/lang/plsql/ast/JJTPLSQLParserState.java14
net/sourceforge/pmd/lang/vm/ast/JJTVmParserState.java14
  public JJTJavaParserState() {
    nodes = new java.util.ArrayList<Node>();
    marks = new java.util.ArrayList<Integer>();
    sp = 0;
    mk = 0;
  }

  /* Determines whether the current node was actually closed and
     pushed.  This should only be called in the final user action of a
     node scope.  */
  public boolean nodeCreated() {
    return node_created;
  }

  /* Call this to reinitialize the node stack.  It is called
     automatically by the parser's ReInit() method. */
  public void reset() {
    nodes.clear();
    marks.clear();
    sp = 0;
    mk = 0;
  }

  /* Returns the root node of the AST.  It only makes sense to call
     this after a successful parse. */
  public Node rootNode() {
    return nodes.get(0);
  }

  /* Pushes a node on to the stack. */
  public void pushNode(Node n) {
    nodes.add(n);
    ++sp;
  }

  /* Returns the node on the top of the stack, and remove it from the
     stack.  */
  public Node popNode() {
    if (--sp < mk) {
      mk = marks.remove(marks.size()-1);
    }
    return nodes.remove(nodes.size()-1);
  }

  /* Returns the node currently on the top of the stack. */
  public Node peekNode() {
    return nodes.get(nodes.size()-1);
  }

  /* Returns the number of children on the stack in the current node
     scope. */
  public int nodeArity() {
    return sp - mk;
  }


  public void clearNodeScope(Node n) {
    while (sp > mk) {
      popNode();
    }
    mk = marks.remove(marks.size()-1);
  }


  public void openNodeScope(Node n) {
    marks.add(mk);
    mk = sp;
    n.jjtOpen();
  }


  /* A definite node is constructed from a specified number of
     children.  That number of nodes are popped from the stack and
     made the children of the definite node.  Then the definite node
     is pushed on to the stack. */
  public void closeNodeScope(Node n, int num) {
    mk = marks.remove(marks.size()-1);
    while (num-- > 0) {
      Node c = popNode();
      c.jjtSetParent(n);
      n.jjtAddChild(c, num);
    }
    n.jjtClose();
    pushNode(n);
    node_created = true;
  }


  /* A conditional node is constructed if its condition is true.  All
     the nodes that have been pushed since the node was opened are
     made children of the conditional node, which is then pushed
     on to the stack.  If the condition is false the node is not
     constructed and they are left on the stack. */
  public void closeNodeScope(Node n, boolean condition) {
    if (condition) {
      int a = nodeArity();
      mk = marks.remove(marks.size()-1);
      while (a-- > 0) {
        Node c = popNode();
        c.jjtSetParent(n);
        n.jjtAddChild(c, a);
      }
      n.jjtClose();
      pushNode(n);
      node_created = true;
    } else {
      mk = marks.remove(marks.size()-1);
      node_created = false;
    }
  }
}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2197
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5485
         }
         break;
     }
     if (jjmatchedKind != 0x7fffffff)
     {
        if (jjmatchedPos + 1 < curPos)
           input_stream.backup(curPos - jjmatchedPos - 1);
        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           matchedToken = jjFillToken();
           matchedToken.specialToken = specialToken;
           TokenLexicalActions(matchedToken);
       if (jjnewLexState[jjmatchedKind] != -1)
         curLexState = jjnewLexState[jjmatchedKind];
           return matchedToken;
        }
        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
           {
              matchedToken = jjFillToken();
              if (specialToken == null)
                 specialToken = matchedToken;
              else
              {
                 matchedToken.specialToken = specialToken;
                 specialToken = (specialToken.next = matchedToken);
              }
              SkipLexicalActions(matchedToken);
           }
           else
              SkipLexicalActions(null);
         if (jjnewLexState[jjmatchedKind] != -1)
           curLexState = jjnewLexState[jjmatchedKind];
           continue EOFLoop;
        }
        MoreLexicalActions();
      if (jjnewLexState[jjmatchedKind] != -1)
        curLexState = jjnewLexState[jjmatchedKind];
        curPos = 0;
        jjmatchedKind = 0x7fffffff;
        try {
           curChar = input_stream.readChar();
           continue;
        }
        catch (java.io.IOException e1) { }
     }
     int error_line = input_stream.getEndLine();
     int error_column = input_stream.getEndColumn();
     String error_after = null;
     boolean EOFSeen = false;
     try { input_stream.readChar(); input_stream.backup(1); }
     catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
           error_line++;
           error_column = 0;
        }
        else
           error_column++;
     }
     if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
     }
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
   }
  }
}

void SkipLexicalActions(Token matchedToken)
{
   switch(jjmatchedKind)
   {
      case 6 :
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java615
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java703
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTCompoundTriggerBlock node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTNonDMLTrigger node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDDLEvent node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDatabaseEvent node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTNonDMLEvent node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAlterTrigger node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTKEYWORD_RESERVED node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTKEYWORD_UNRESERVED node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTID node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTUnqualifiedID node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTQualifiedID node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTypeKeyword node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTJavaInterfaceClass node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTEqualsOldIDNewID node, Object data) {
		return visit((PLSQLNode) node, data);
	}

        @Override
        public Object visit(ASTAccessibleByClause node, Object data) {
                return visit((PLSQLNode) node, data);
        }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
};
static final long[] jjtoToken = {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10523
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39771
    for (int i = 0; i < 151; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken = token;
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    else jj_nt = jj_nt.next = token_source.getNextToken();
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    jj_nt = token;
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    else jj_nt = jj_nt.next = token_source.getNextToken();
    jj_gen++;
    return token;
  }

/** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = jj_lookingAhead ? jj_scanpos : token;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21267
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22470
        break;
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMEZONE_REGION:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21268
          case REPLACE:
          case DEFINER:
          case CURRENT_USER:
          case LANGUAGE:
          case INLINE:
          case ADD:
          case AGGREGATE:
          case ARRAY:
          case AT:
          case ATTRIBUTE:
          case AUTHID:
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, 1, 2, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
};
static final long[] jjtoToken = {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22231
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMEZONE_REGION:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16529
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18304
      case IMMEDIATE:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13920
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22350
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22592
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29038
          case PRAGMA:
          case PRESERVE:
          case PRIOR:
          case PROMPT:
          case PRIVATE:
          case PROCEDURE:
          case PUBLIC:
          case RAISE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case ROWTYPE:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELECT:
          case SELF:
          case SEPARATE:
          case SET:
          case SHARE:
          case SMALLINT:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case START:
          case STATIC:
          case STDDEV:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SUM:
          case SYNONYM:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TABLE:
          case TEMPORARY:
          case THEN:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TO:
          case TRANSACTION:
          case TRIGGER:
          case TRUE:
          case TYPE:
          case UI:
          case UNDER:
          case USING:
          case WHILE:
          case YES:
          case SHOW:
          case A:
          case UPDATE:
          case VARCHAR:
          case VARCHAR2:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case SIGNTYPE:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case WITH:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10585
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39833
    Token t = jj_lookingAhead ? jj_scanpos : token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
        int[] oldentry = (int[])(it.next());
        if (oldentry.length == jj_expentry.length) {
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              continue jj_entries_loop;
            }
          }
          jj_expentries.add(jj_expentry);
          break jj_entries_loop;
        }
      }
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[128];
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2328
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4151
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29038
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29038
        case POSITIVEN:
        case PRESERVE:
        case PRIOR:
        case PROMPT:
        case PRIVATE:
        case PROCEDURE:
        case PUBLIC:
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case ROWTYPE:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SEPARATE:
        case SET:
        case SHARE:
        case SMALLINT:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case START:
        case STATIC:
        case STDDEV:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SUM:
        case SYNONYM:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TABLE:
        case TEMPORARY:
        case THEN:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TO:
        case TRANSACTION:
        case TRIGGER:
        case TRUE:
        case TYPE:
        case UI:
        case UNDER:
        case USING:
        case WHILE:
        case YES:
        case SHOW:
        case A:
        case UPDATE:
        case VARCHAR:
        case VARCHAR2:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1030
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1769
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20939
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23710
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24665
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25456
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25818
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27159
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28472
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28945
        case EXTERNAL:
        case EXTENDS:
        case EXTRACT:
        case FALSE:
        case FETCH:
        case FINAL:
        case FLOAT:
        case FOR:
        case FORALL:
        case FORCE:
        case FROM:
        case FUNCTION:
        case GLOBAL:
        case GOTO:
        case GROUP:
        case HASH:
        case HAVING:
        case HEAP:
        case HOUR:
        case IF:
        case IMMEDIATE:
        case IN:
        case INDEX:
        case INDICES:
        case INDEXTYPE:
        case INDICATOR:
        case INSERT:
        case INSTANTIABLE:
        case INTEGER:
        case INTERFACE:
        case INTERSECT:
        case INTERVAL:
        case INTO:
        case INVALIDATE:
        case IS:
        case ISOLATION:
        case JAVA:
        case LEVEL:
        case LIKE:
        case LIMIT:
        case LIMITED:
        case LOCK:
        case LONG:
        case LOOP:
        case MAP:
        case MAX:
        case MEMBER:
        case MERGE:
        case MIN:
        case MINUS:
        case MINUTE:
        case MLSLABEL:
        case MODIFY:
        case MOD:
        case MODE:
        case MONTH:
        case NATURAL:
        case NATURALN:
        case NEW:
        case NEXTVAL:
        case NO:
        case NOCOPY:
        case NONEDITIONABLE:
        case NOT:
        case NOWAIT:
        case NULL:
        case NULLIF:
        case NUMBER:
        case BFILE_BASE:
        case BLOB_BASE:
        case CLOB_BASE:
        case DATE_BASE:
        case NUMBER_BASE:
        case OBJECT:
        case OCIROWID:
        case OF:
        case OID:
        case ON:
        case OPAQUE:
        case OPEN:
        case OPERATOR:
        case OPTION:
        case OR:
        case ORDER:
        case ORGANIZATION:
        case OTHERS:
        case OUT:
        case OVERRIDING:
        case PACKAGE:
        case PARTITION:
        case PCTFREE:
        case PLS_INTEGER:
        case POSITIVE:
        case POSITIVEN:
        case PRESERVE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java456
net/sourceforge/pmd/lang/ast/SimpleCharStream.java405
        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;
    }

    /**
     * @see org.apache.velocity.runtime.parser.CharStream#Done()
     */
    public void Done()
    {
        buffer = null;
        bufline = null;
        bufcolumn = null;
    }

    /**
     * Method to adjust line and column numbers for the start of a token.<BR>
     * @param newLine
     * @param newCol
     */
    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];
    }

}
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15758
        jj_consume_token(8);
        break;
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BINARY_INTEGER:
      case BODY:
      case BOOLEAN:
      case BULK:
      case BYTE:
      case CASCADE:
      case CHAR:
      case CHAR_BASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DECIMAL:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FLOAT:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTEGER:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LONG:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NATURALN:
      case NEW:
      case NO:
      case NONEDITIONABLE:
      case NULLIF:
      case NUMBER:
      case BFILE_BASE:
      case BLOB_BASE:
      case CLOB_BASE:
      case DATE_BASE:
      case NUMBER_BASE:
      case OBJECT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java524
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java603
	public Object visit(ASTInlinePragma node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTExceptionDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTParallelClause node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTable node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTableColumn node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTView node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSynonym node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDirectory node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDatabaseLink node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTViewColumn node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTComment node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTypeMethod node, Object data) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java709
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1577
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2792
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3511
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10840
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11442
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11774
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12086
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12398
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14845
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23523
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27840
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java311
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2865
                  jjCheckNAddStates(0, 2);
                  break;
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(3, 6);
                  break;
               case 3:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(16, 17);
                  break;
               case 6:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(18, 19);
                  break;
               case 11:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(7, 10);
                  break;
               case 13:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(20, 21);
                  break;
               case 16:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(22, 23);
                  break;
               case 21:
               case 23:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(11, 13);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
private int jjMoveStringLiteralDfa0_5()
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4298
   if (lexState >= 3 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

protected Token jjFillToken()
{
   final Token t;
   final String curTokenImage;
   final int beginLine;
   final int endLine;
   final int beginColumn;
   final int endColumn;
   String im = jjstrLiteralImages[jjmatchedKind];
   curTokenImage = (im == null) ? input_stream.GetImage() : im;
   beginLine = input_stream.getBeginLine();
   beginColumn = input_stream.getBeginColumn();
   endLine = input_stream.getEndLine();
   endColumn = input_stream.getEndColumn();
   t = Token.newToken(jjmatchedKind, curTokenImage);

   t.beginLine = beginLine;
   t.endLine = endLine;
   t.beginColumn = beginColumn;
   t.endColumn = endColumn;

   return t;
}

int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

/** Get the next Token. */
public Token getNextToken() 
{
  Token specialToken = null;
  Token matchedToken;
  int curPos = 0;

  EOFLoop :
  for (;;)
  {
   try
   {
      curChar = input_stream.BeginToken();
   }
   catch(java.io.IOException e)
   {
      jjmatchedKind = 0;
      matchedToken = jjFillToken();
      matchedToken.specialToken = specialToken;
      return matchedToken;
   }
   image = jjimage;
   image.setLength(0);
   jjimageLen = 0;

   for (;;)
   {
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
         break;
       case 1:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_1();
         if (jjmatchedPos == 0 && jjmatchedKind > 11)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3141
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4578
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5579
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10210
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14243
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17022
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23261
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12723
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13054
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19808
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20474
      case NOT:
      case NULL:
      case NULLIF:
      case OBJECT:
      case OID:
      case OPAQUE:
      case OPEN:
      case OPERATOR:
      case ORGANIZATION:
      case OTHERS:
      case OVERRIDING:
      case PACKAGE:
      case PARTITION:
      case PRESERVE:
      case PRIVATE:
      case PROCEDURE:
      case RANGE:
      case RAW:
      case REAL:
      case RECORD:
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELECT:
      case SELF:
      case SET:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case WITH:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10591
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39839
net/sourceforge/pmd/lang/vm/ast/VmParser.java3680
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
        int[] oldentry = (int[])(it.next());
        if (oldentry.length == jj_expentry.length) {
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              continue jj_entries_loop;
            }
          }
          jj_expentries.add(jj_expentry);
          break jj_entries_loop;
        }
      }
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[128];
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1201
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9583
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16623
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17435
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18398
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18679
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18963
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24487
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24836
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25989
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26600
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28643
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15922
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
        Datatype();
        break;
      default:
        jj_la1[72] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18532
        simpleNode = UnaryExpression(false);
                                            sb.append(simpleNode.getImage());
        break;
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7572
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21408
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22370
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31149
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31450
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3805
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java4893
               case 33:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  else if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 2:
                  if ((0x10000000100000L & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 5:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 6:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  break;
               case 7:
                  if (curChar == 125)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 8:
                  if ((0x10000000100000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 7;
                  break;
               case 9:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 8;
                  break;
               case 10:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 9;
                  break;
               case 11:
                  if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 13:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 68)
                     kind = 68;
                  jjCheckNAdd(13);
                  break;
               case 15:
                  if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
                     kind = 69;
                  break;
               case 17:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3141
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4578
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5579
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19876
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23261
        case SIGNTYPE:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18818
        simpleNode = UnaryExpression(false);
                                            sb.append(simpleNode.getImage());
        break;
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
};
static final long[] jjtoToken = {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18253
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NULL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20397
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19060
      switch (jj_nt.kind) {
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28273
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            ;
            break;
          default:
            jj_la1[345] = jj_gen;
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java311
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2865
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3800
                  jjCheckNAddStates(0, 2);
                  break;
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(3, 6);
                  break;
               case 3:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(16, 17);
                  break;
               case 6:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(18, 19);
                  break;
               case 11:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(7, 10);
                  break;
               case 13:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(20, 21);
                  break;
               case 16:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(22, 23);
                  break;
               case 21:
               case 23:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(11, 13);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3154
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4591
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23274
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java103
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java130
	if (occurrence.isOnLeftHandSide()) {
	    this.addVariableAccess(occurrence.getLocation(), new VariableAccess(VariableAccess.DEFINITION, occurrence
		    .getImage()), inode.getFlow());
	} else if (occurrence.isOnRightHandSide() || !occurrence.isOnLeftHandSide() && !occurrence.isOnRightHandSide()) {
	    this.addVariableAccess(occurrence.getLocation(), new VariableAccess(VariableAccess.REFERENCING, occurrence
		    .getImage()), inode.getFlow());
	}
    }

    /**
     * Adds a VariableAccess to a dataflow node.
     * @param node location of the access of a variable
     * @param va variable access to add
     * @param flow dataflownodes that can contain the node.
     */
    private void addVariableAccess(Node node, VariableAccess va, List<DataFlowNode> flow) {
	// backwards to find the right inode (not a method declaration)
	for (int i = flow.size() - 1; i > 0; i--) {
	    DataFlowNode inode = flow.get(i);
	    if (inode.getNode() == null) {
		continue;
	    }

	    List<? extends Node> children = inode.getNode().findDescendantsOfType(node.getClass());
	    for (Node n : children) {
		if (node.equals(n)) {
		    List<VariableAccess> v = new ArrayList<VariableAccess>();
		    v.add(va);
		    inode.setVariableAccess(v);
		    return;
		}
	    }
	}
    }

}
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12804
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13135
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14256
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20555
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7581
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22621
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23894
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28656
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1957
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7138
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23898
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24853
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26617
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27347
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28660
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18820
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19061
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28275
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ;
          break;
        default:
          jj_la1[33] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7581
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9596
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17448
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18411
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18976
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22621
          case LOCAL:
          case ZONE:
          case CHARACTER:
          case AFTER:
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20397
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9596
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17448
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18411
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18976
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23894
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28656
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30515
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31158
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31459
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28662
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14263
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          Expression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java471
net/sourceforge/pmd/lang/ast/JavaCharStream.java564
net/sourceforge/pmd/lang/ast/SimpleCharStream.java418
        buffer = null;
        bufline = null;
        bufcolumn = null;
    }

    /**
     * Method to adjust line and column numbers for the start of a token.<BR>
     * @param newLine
     * @param newCol
     */
    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];
    }

}
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19223
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          simpleNode = ConditionalOrExpression();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27861
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java69
net/sourceforge/pmd/lang/ast/SimpleCharStream.java43
        int newbufcolumn[] = new int[bufsize + nextBufExpand];

        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;

                maxNextCharInd = (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;

                maxNextCharInd = (bufpos -= tokenBegin);
            }
        }
        catch (Throwable t)
        {
            throw new Error(t.getMessage());
        }


        bufsize += nextBufExpand;
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7585
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21421
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22383
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22625
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28273
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5337
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23020
            case LANGUAGE:
            case INLINE:
            case ADD:
            case AGGREGATE:
            case ALL:
            case ALTER:
            case AND:
            case ANY:
            case ARRAY:
            case AS:
            case ASC:
            case AT:
            case ATTRIBUTE:
            case AUTHID:
            case AVG:
            case BEGIN:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9600
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17452
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18415
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18696
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28273
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/ast/TokenMgrError.java50
net/sourceforge/pmd/lang/java/ast/ParseException.java141
net/sourceforge/pmd/lang/jsp/ast/ParseException.java141
net/sourceforge/pmd/lang/plsql/ast/ParseException.java159
net/sourceforge/pmd/lang/vm/ast/ParseException.java141
  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();
  }
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28662
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23281
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31162
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31463
        case INSTEADOF:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            if (jj_2_75(2)) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28662
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java1873
net/sourceforge/pmd/lang/vm/ast/VmParser.java1969
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void ElseIfStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1964
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2818
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3166
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3885
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4603
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5147
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5604
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7145
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23286
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23905
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24511
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25651
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26013
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28280
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19889
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31164
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31465
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/rule/codesize/CyclomaticComplexityRule.java42
net/sourceforge/pmd/lang/plsql/rule/codesize/CyclomaticComplexityRule.java44
    public static final IntegerProperty REPORT_LEVEL_DESCRIPTOR = new IntegerProperty("reportLevel",
	    "Cyclomatic Complexity reporting threshold", 1, 30, 10, 1.0f);

    public static final BooleanProperty SHOW_CLASSES_COMPLEXITY_DESCRIPTOR = new BooleanProperty("showClassesComplexity",
	"Add class average violations to the report", true, 2.0f);

    public static final BooleanProperty SHOW_METHODS_COMPLEXITY_DESCRIPTOR = new BooleanProperty("showMethodsComplexity",
	"Add method average violations to the report", true, 3.0f);

  private int reportLevel;
  private boolean showClassesComplexity = true;
  private boolean showMethodsComplexity = true;

  private static class Entry {
    private Node node;
    private int decisionPoints = 1;
    public int highestDecisionPoints;
    public int methodCount;

    private Entry(Node node) {
      this.node = node;
    }

    public void bumpDecisionPoints() {
      decisionPoints++;
    }

    public void bumpDecisionPoints(int size) {
      decisionPoints += size;
    }

    public int getComplexityAverage() {
      return (double) methodCount == 0 ? 1
          : (int) Math.rint( (double) decisionPoints / (double) methodCount );
    }
  }

  private Stack<Entry> entryStack = new Stack<Entry>();

  public CyclomaticComplexityRule() {
      definePropertyDescriptor(REPORT_LEVEL_DESCRIPTOR);
      definePropertyDescriptor(SHOW_CLASSES_COMPLEXITY_DESCRIPTOR);
      definePropertyDescriptor(SHOW_METHODS_COMPLEXITY_DESCRIPTOR);
  }

  @Override
public Object visit(ASTCompilationUnit node, Object data) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4430
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5522
      if (jjnewLexState[jjmatchedKind] != -1)
        curLexState = jjnewLexState[jjmatchedKind];
        curPos = 0;
        jjmatchedKind = 0x7fffffff;
        try {
           curChar = input_stream.readChar();
           continue;
        }
        catch (java.io.IOException e1) { }
     }
     int error_line = input_stream.getEndLine();
     int error_column = input_stream.getEndColumn();
     String error_after = null;
     boolean EOFSeen = false;
     try { input_stream.readChar(); input_stream.backup(1); }
     catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
           error_line++;
           error_column = 0;
        }
        else
           error_column++;
     }
     if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
     }
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
   }
  }
}

void SkipLexicalActions(Token matchedToken)
{
   switch(jjmatchedKind)
   {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13414
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13960
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22390
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
FileLine
net/sourceforge/pmd/lang/ast/JavaCharStream.java83
net/sourceforge/pmd/lang/ast/SimpleCharStream.java32
  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;
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java735
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1603
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5867
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8614
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8888
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9907
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10235
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10566
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11168
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11468
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12112
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12424
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12816
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13147
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14268
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14871
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15153
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17459
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18422
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18987
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20567
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10167
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12748
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14200
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19833
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20499
        case RESULT:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case YES:
        case SHOW:
        case A:
        case DOUBLE:
        case DEC:
        case PRECISION:
        case INT:
        case NUMERIC:
        case NCHAR:
        case NVARCHAR2:
        case STRING:
        case UROWID:
        case VARRAY:
        case VARYING:
        case BFILE:
        case BLOB:
        case CLOB:
        case NCLOB:
        case YEAR:
        case LOCAL:
        case WITH:
        case ZONE:
        case CHARACTER:
        case AFTER:
        case BEFORE:
        case OLD:
        case PARENT:
        case ANALYZE:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java6438
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1172
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_2(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(1, xla); }
  }

  private boolean jj_2_3(int xla) {
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java222
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2776
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3711
                  jjCheckNAddStates(0, 2);
                  if (curChar == 92)
                     jjAddStates(14, 15);
                  break;
               case 0:
                  if (curChar == 123)
                     jjCheckNAddStates(3, 6);
                  break;
               case 1:
                  if ((0xdfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(3, 6);
                  break;
               case 3:
                  jjAddStates(16, 17);
                  break;
               case 6:
                  jjAddStates(18, 19);
                  break;
               case 8:
                  if (curChar == 125 && kind > 70)
                     kind = 70;
                  break;
               case 10:
                  if (curChar == 123)
                     jjCheckNAddStates(7, 10);
                  break;
               case 11:
                  if ((0xdfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(7, 10);
                  break;
               case 13:
                  jjAddStates(20, 21);
                  break;
               case 16:
                  jjAddStates(22, 23);
                  break;
               case 18:
                  if (curChar == 125 && kind > 71)
                     kind = 71;
                  break;
               case 21:
               case 23:
                  jjCheckNAddStates(11, 13);
                  break;
               case 28:
                  if (kind > 79)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31169
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31470
      case COMPOUND:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1619
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4430
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5522
      if (jjnewLexState[jjmatchedKind] != -1)
        curLexState = jjnewLexState[jjmatchedKind];
        curPos = 0;
        jjmatchedKind = 0x7fffffff;
        try {
           curChar = input_stream.readChar();
           continue;
        }
        catch (java.io.IOException e1) { }
     }
     int error_line = input_stream.getEndLine();
     int error_column = input_stream.getEndColumn();
     String error_after = null;
     boolean EOFSeen = false;
     try { input_stream.readChar(); input_stream.backup(1); }
     catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
           error_line++;
           error_column = 0;
        }
        else
           error_column++;
     }
     if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
     }
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
   }
  }
}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19896
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31164
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31465
        case CC_ERROR:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/symboltable/ScopeAndDeclarationFinder.java278
net/sourceforge/pmd/lang/plsql/symboltable/ScopeAndDeclarationFinder.java316
public Object visit(ASTTypeMethod node, Object data) {
	createMethodScope(node);
	ASTMethodDeclarator md = node.getFirstChildOfType(ASTMethodDeclarator.class);
	// A PLSQL Method (FUNCTION|PROCEDURE) may be schema-level 
	try
	{
	  node.getScope().getEnclosingScope(ClassScope.class).addDeclaration(new MethodNameDeclaration(md));
	}
	catch (Exception e)
	{
	  //@TODO possibly add to a pseudo-ClassScope equivalent to the Schema name 
	  LOGGER.finest("ProgramUnit getEnclosingClassScope Exception string=\""+e.getMessage()+"\"");
	  if("getEnclosingClassScope() called on SourceFileScope".equals(e.getMessage()))
	  {
            LOGGER.finest("ClassScope skipped for Schema-level method: methodName=" 
		               + node.getMethodName()
		               + "; Image=" + node.getImage()
		              );
	   
	    //A File-level/Schema-level object may have a Schema-name explicitly specified in the declaration 
	    ASTObjectNameDeclaration on = md.getFirstChildOfType(ASTObjectNameDeclaration.class);
	    if( 1 < on.jjtGetNumChildren())
	    {
              ASTID schemaName = on.getFirstChildOfType(ASTID.class);
	      LOGGER.finest("SchemaName for Schema-level method: methodName=" 
				 + node.getMethodName()
				 + "; Image=" + node.getImage()
				 + "is " + schemaName.getImage()
				);
	     
	    }
	  }
	}
	cont(node);
	return data;
  }

    @Override
    public Object visit(ASTProgramUnit node, Object data) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7774
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16798
        simpleNode = Datatype();
                                      sb.append(" "); sb.append(simpleNode.getImage());
      }
      jj_consume_token(CC_END);
                    sb.append(" "); sb.append(token.image);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/symboltable/TypeSet.java130
net/sourceforge/pmd/lang/plsql/symboltable/TypeSet.java130
    public String getASTCompilationUnitPackage() {
	return pkg;
    }

    public void addImport(String importString) {
	imports.add(importString);
    }

    public int getImportsCount() {
	return imports.size();
    }

    public Class<?> findClass(String name) throws ClassNotFoundException {
	// we don't build the resolvers until now since we first want to get all the imports
	if (resolvers.isEmpty()) {
	    buildResolvers();
	}

	for (Resolver resolver : resolvers) {
	    try {
		return resolver.resolve(name);
	    } catch (ClassNotFoundException cnfe) {
	    }
	}

	throw new ClassNotFoundException("Type " + name + " not found");
    }

    private void buildResolvers() {
	resolvers.add(new PrimitiveTypeResolver());
	resolvers.add(new VoidResolver());
	resolvers.add(new ExplicitImportResolver(imports));
	resolvers.add(new CurrentPackageResolver(pkg));
	resolvers.add(new ImplicitImportResolver());
	resolvers.add(new ImportOnDemandResolver(imports));
	resolvers.add(new FullyQualifiedNameResolver());
    }

}
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10546
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1639
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39794
net/sourceforge/pmd/lang/vm/ast/VmParser.java3627
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15867
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SMALLINT:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case VARCHAR:
      case VARCHAR2:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case SIGNTYPE:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java42
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java64
    public void compute(ASTConstructorDeclaration node) {
	this.computeNow(node);
    }

    private void computeNow(Node node) {
	DataFlowNode inode = node.getDataFlowNode();

	List<VariableAccess> undefinitions = markUsages(inode);

	// all variables are first in state undefinition
	DataFlowNode firstINode = inode.getFlow().get(0);
	firstINode.setVariableAccess(undefinitions);

	// all variables are getting undefined when leaving scope
	DataFlowNode lastINode = inode.getFlow().get(inode.getFlow().size() - 1);
	lastINode.setVariableAccess(undefinitions);
    }

    private List<VariableAccess> markUsages(DataFlowNode inode) {
	// undefinitions was once a field... seems like it works fine as a local
	List<VariableAccess> undefinitions = new ArrayList<VariableAccess>();
	Set<Map<NameDeclaration, List<NameOccurrence>>> variableDeclarations = collectDeclarations(inode);
	for (Map<NameDeclaration, List<NameOccurrence>> declarations : variableDeclarations) {
	    for (Map.Entry<NameDeclaration, List<NameOccurrence>> entry : declarations.entrySet()) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2914
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3284
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java3633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4897
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23655
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java24610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25401
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25763
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28890
        case AVG:
        case BETWEEN:
        case BINARY_INTEGER:
        case BODY:
        case BOOLEAN:
        case BULK:
        case BY:
        case BYTE:
        case CASCADE:
        case CASE:
        case CHAR:
        case CHAR_BASE:
        case CHECK:
        case CLOSE:
        case CLUSTER:
        case COALESCE:
        case COLLECT:
        case COLUMN:
        case COMMENT:
        case COMMIT:
        case COMPRESS:
        case CONNECT:
        case CONSTANT:
        case CONSTRUCTOR:
        case CONTINUE:
        case CONVERT:
        case CREATE:
        case CURRENT:
        case CURRVAL:
        case CURSOR:
        case DATA:
        case DATE:
        case DAY:
        case DECLARE:
        case DECIMAL:
        case _DEFAULT:
        case DELETE:
        case DESC:
        case DISABLE:
        case DISTINCT:
        case DO:
        case DROP:
        case EDITIONABLE:
        case ELEMENT:
        case ELSE:
        case ELSIF:
        case ENABLE:
        case ESCAPE:
        case EXCEPT:
        case EXCEPTION:
        case EXCEPTIONS:
        case EXCLUSIVE:
        case EXECUTE:
        case EXISTS:
        case EXIT:
        case EXTERNAL:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19901
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29139
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case AUTHENTICATED:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/ast/JavaCharStream.java530
net/sourceforge/pmd/lang/ast/SimpleCharStream.java386
    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()
  {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19727
        Expression();
        break;
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDEXTYPE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12645
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16476
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20395
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };

/** Lexer state names. */
public static final String[] lexStateNames = {
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2390
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3810
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java4444
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java4898
                  break;
               case 2:
                  if ((0x10000000100000L & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 5:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 6:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  break;
               case 7:
                  if (curChar == 125)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 8:
                  if ((0x10000000100000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 7;
                  break;
               case 9:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 8;
                  break;
               case 10:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 9;
                  break;
               case 11:
                  if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 12:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2428
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3481
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/symboltable/ClassScope.java106
net/sourceforge/pmd/lang/plsql/symboltable/ClassScope.java111
                (occurrence.getImage() != null && occurrence.getImage().equals(className))) {
            if (variableDeclarations.isEmpty() && methodDeclarations.isEmpty()) {
                // this could happen if you do this:
                // public class Foo {
                //  private String x = super.toString();
                // }
                return null;
            }
            // return any name declaration, since all we really want is to get the scope
            // for example, if there's a
            // public class Foo {
            //  private static final int X = 2;
            //  private int y = Foo.X;
            // }
            // we'll look up Foo just to get a handle to the class scope
            // and then we'll look up X.
            if (!variableDeclarations.isEmpty()) {
                return variableDeclarations.keySet().iterator().next();
            }
            return methodDeclarations.keySet().iterator().next();
        }

        if (occurrence.isMethodOrConstructorInvocation()) {
            for (MethodNameDeclaration mnd: methodDeclarations.keySet()) {
                if (mnd.getImage().equals(occurrence.getImage())) {
                    int args = occurrence.getArgumentCount();
                    if (args == mnd.getParameterCount() || (mnd.isVarargs() && args >= mnd.getParameterCount() - 1)) {
                        // FIXME if several methods have the same name
                        // and parameter count, only one will get caught here
                        // we need to make some attempt at type lookup and discrimination
                        // or, failing that, mark this as a usage of all those methods
                        return mnd;
                    }
                }
            }
            return null;
        }

        List<String> images = new ArrayList<String>();
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12553
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26298
 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
    try {
      simpleNode = ID();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1494
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4298
   if (lexState >= 5 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

protected Token jjFillToken()
{
   final Token t;
   final String curTokenImage;
   final int beginLine;
   final int endLine;
   final int beginColumn;
   final int endColumn;
   String im = jjstrLiteralImages[jjmatchedKind];
   curTokenImage = (im == null) ? input_stream.GetImage() : im;
   beginLine = input_stream.getBeginLine();
   beginColumn = input_stream.getBeginColumn();
   endLine = input_stream.getEndLine();
   endColumn = input_stream.getEndColumn();
   t = Token.newToken(jjmatchedKind, curTokenImage);

   t.beginLine = beginLine;
   t.endLine = endLine;
   t.beginColumn = beginColumn;
   t.endColumn = endColumn;

   return t;
}

int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

/** Get the next Token. */
public Token getNextToken() 
{
  Token matchedToken;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20358
        simpleNode = Expression();
                                    sb.append("."); sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTTrimExpression TrimExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31736
        jj_la1[442] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

/**
 * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
 */
  final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19061
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDEXTYPE:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1302
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6835
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22167
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22723
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27605
        jj_la1[19] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPackageBody PackageBody() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18493
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18774
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19316
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19985
        jj_la1[247] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
   if (jjtc000) {
     jjtree.clearNodeScope(jjtn000);
     jjtc000 = false;
   } else {
     jjtree.popNode();
   }
   if (jjte000 instanceof RuntimeException) {
     {if (true) throw (RuntimeException)jjte000;}
   }
   if (jjte000 instanceof ParseException) {
     {if (true) throw (ParseException)jjte000;}
   }
   {if (true) throw (Error)jjte000;}
    } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000, true);
   }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17715
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18128
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20309
        simpleNode = ConditionalAndExpression();
                                                sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/dcd/graph/ConstructorNode.java60
net/sourceforge/pmd/dcd/graph/MethodNode.java39
	public int compareTo(ConstructorNode that) {
		// Order by name
		int cmp = this.getName().compareTo(that.getName());
		if (cmp == 0) {
			// Order by parameter list length
			cmp = this.getMember().getParameterTypes().length - that.getMember().getParameterTypes().length;
			if (cmp == 0) {
				// Order by parameter class name
				for (int i = 0; i < this.getMember().getParameterTypes().length; i++) {
					cmp = this.getMember().getParameterTypes()[i].getName().compareTo(
							that.getMember().getParameterTypes()[i].getName());
					if (cmp != 0) {
						break;
					}
				}
			}
		}
		return cmp;
	}

	public boolean equals(Object obj) {
		if (obj instanceof ConstructorNode) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/Token.java9
net/sourceforge/pmd/lang/jsp/ast/Token.java9
net/sourceforge/pmd/lang/plsql/ast/Token.java27
net/sourceforge/pmd/lang/vm/ast/Token.java9
public class Token implements java.io.Serializable {

  /**
   * The version identifier for this Serializable class.
   * Increment only if the <i>serialized</i> form of the
   * class changes.
   */
  private static final long serialVersionUID = 1L;

  /**
   * 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);
  }

}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13490
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13763
        jj_la1[147] = jj_gen;
        ;
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTExitStatement ExitStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17715
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18128
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20309
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20359
                                    sb.append("."); sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTTrimExpression TrimExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/ast/JavaCharStream.java214
net/sourceforge/pmd/lang/ast/SimpleCharStream.java140
  }

  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];
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17537
      jj_consume_token(7);
       sb.append(")");
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1658
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1869
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2074
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2703
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3456
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5173
                     jjAddStates(98, 99);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 98 - (jjnewStateCnt = startsAt)))
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/TokenMgrError.java44
net/sourceforge/pmd/lang/ast/TokenMgrError.java51
net/sourceforge/pmd/lang/java/ast/ParseException.java142
net/sourceforge/pmd/lang/jsp/ast/ParseException.java142
net/sourceforge/pmd/lang/plsql/ast/ParseException.java160
net/sourceforge/pmd/lang/vm/ast/ParseException.java142
        final 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) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16390
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16422
  ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      CursorUnit();
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCursorBody CursorBody() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7442
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13264
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13810
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19389
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22240
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22482
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31332
          case BODY:
          case BULK:
          case BYTE:
          case CASCADE:
          case CLOSE:
          case COALESCE:
          case COLLECT:
          case COLUMN:
          case COMMENT:
          case COMMIT:
          case CONSTRUCTOR:
          case CONTINUE:
          case CONVERT:
          case CURRENT:
          case CURSOR:
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7457
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13825
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19404
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21294
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22497
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
          case NONEDITIONABLE:
          case NULLIF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9678
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16285
          jj_la1[120] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTStatement Statement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6312
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6752
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15516
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26752
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29385
        jj_la1[69] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6700
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25076
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26207
        jj_la1[74] = jj_gen;
        ;
      }
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7319
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8362
        jj_la1[85] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21573
      jj_consume_token(4);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCursorSpecification CursorSpecification() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/symboltable/MethodNameDeclaration.java49
net/sourceforge/pmd/lang/plsql/symboltable/MethodNameDeclaration.java67
            sb.append(',');
        }
        if (sb.charAt(sb.length() - 1) == ',') {
            sb.deleteCharAt(sb.length() - 1);
        }
        sb.append(')');
        return sb.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof MethodNameDeclaration)) {
            return false;
        }

        MethodNameDeclaration other = (MethodNameDeclaration) o;

        // compare name
        if (!other.node.getImage().equals(node.getImage())) {
            return false;
        }

        // compare parameter count - this catches the case where there are no params, too
        if (((ASTMethodDeclarator) other.node).getParameterCount() != ((ASTMethodDeclarator) node).getParameterCount()) {
            return false;
        }

        // compare parameter types
        ASTFormalParameters myParams = (ASTFormalParameters) node.jjtGetChild(0);
FileLine
net/sourceforge/pmd/lang/ast/JavaCharStream.java491
net/sourceforge/pmd/lang/ast/SimpleCharStream.java346
  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,
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7700
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19657
          }
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCompilationDataType CompilationDataType() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7778
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17152
                    sb.append(" "); sb.append(token.image);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18776
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19987
        Expression();
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/plsql/rule/codesize/CyclomaticComplexityRule.java285
net/sourceforge/pmd/lang/plsql/rule/codesize/CyclomaticComplexityRule.java340
                    || null != node.getFirstParentOfType(ASTTriggerUnit.class) //Trigger of any form
                    //@TODO || null != node.getFirstParentOfType(ASTProgramUnit.class) //Another Procedure
                    //@TODO || null != node.getFirstParentOfType(ASTTypeMethod.class) //Another Type method
               )
            {
              /* @TODO This does not cope with nested methods 
               * We need the outer most 
               * ASTPackageBody
               * ASTTriggerUni
               * ASTProgramUnit
               * ASTTypeMethod
               * 
               */
              Entry classEntry = entryStack.peek();
              classEntry.methodCount++;
              classEntry.bumpDecisionPoints( methodDecisionPoints );

              if ( methodDecisionPoints > classEntry.highestDecisionPoints ) {
                classEntry.highestDecisionPoints = methodDecisionPoints;
              }
            }

	    ASTMethodDeclarator methodDeclarator = null;
	    for ( int n = 0; n < node.jjtGetNumChildren(); n++ ) {
	      Node childNode = node.jjtGetChild( n );
	      if ( childNode instanceof ASTMethodDeclarator ) {
	        methodDeclarator = (ASTMethodDeclarator) childNode;
	        break;
	      }
	    }

	    if ( methodEntry.decisionPoints >= reportLevel ) {
	        addViolation( data, node, new String[] { "method",
	            methodDeclarator == null ? "" : methodDeclarator.getImage(),
	            String.valueOf( methodEntry.decisionPoints ) } );
	      }
    }
    LOGGER.exiting(CLASS_NAME,"visit(ASTProgramUnit)");
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1794
net/sourceforge/pmd/lang/java/ast/JavaParser.java4538
        }
        BlockStatement();
      }
      t = jj_consume_token(RBRACE);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

  final public void ExplicitConstructorInvocation() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java654
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5786
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8533
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8807
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9826
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10485
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10785
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11087
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11387
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11719
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12738
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13069
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14790
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15072
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16570
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17382
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18345
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18626
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18910
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19151
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19823
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20489
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23468
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27785
        case RAISE:
        case RANGE:
        case RAW:
        case REAL:
        case RECORD:
        case REF:
        case RELEASE:
        case RELIES_ON:
        case RENAME:
        case RESULT:
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case WHILE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12557
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26302
      simpleNode = ID();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7701
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16725
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19658
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCompilationDataType CompilationDataType() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17668
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17716
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17783
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18200
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18776
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19987
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20310
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20359
                                    sb.append("."); sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTTrimExpression TrimExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10650
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1748
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39928
net/sourceforge/pmd/lang/vm/ast/VmParser.java3736
    for (int i = 0; i < 128; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    jj_endpos = 0;
    jj_rescan_token();
    jj_add_error_token(0, 0);
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  /** Enable tracing. */
  final public void enable_tracing() {
  }

  /** Disable tracing. */
  final public void disable_tracing() {
  }

  private void jj_rescan_token() {
    jj_rescan = true;
    for (int i = 0; i < 72; i++) {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java302
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12557
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21573
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26302
      SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7235
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7778
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16840
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17152
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17538
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27969
      Skip2NextTokenOccurrence(EOL);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

/*
SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
void attachLibrary() :
{}
{
	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
}
*/

/**
 * All global definitions of triggers, functions and procedures are evaluated here.
 * Every occurence goes under a new PACKAGE-Node in the XML document.
 * This happens, cause a global "block" does not have a definied start and end token 
 * like a package specification or a package body.
 * Thats why every construct is handled like a new part of the global package.
 * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
 * and slow down the whole parsing.
 * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
 * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
 * choose the correct way on a given base. So we can't negate it easily.
 * On the other hand I could also hold the global state in a global variable. 
 * But this does not seems the correct way to solve the problem, I think.
 *
 * 2006-05-17 - Matthias Hendler - added
 */
  final public ASTGlobal Global() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java498
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6313
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6753
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15517
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26753
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29386
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTBlock Block() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2044
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6702
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6838
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22113
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22170
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22726
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25078
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26209
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27608
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPackageBody PackageBody() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7321
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7702
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7867
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16726
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17621
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17669
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17717
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17784
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18016
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18130
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18201
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18496
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18777
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19319
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19659
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19988
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20311
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20360
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36091
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_351() {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1627
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2242
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4438
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5530
        catch (java.io.IOException e1) { }
     }
     int error_line = input_stream.getEndLine();
     int error_column = input_stream.getEndColumn();
     String error_after = null;
     boolean EOFSeen = false;
     try { input_stream.readChar(); input_stream.backup(1); }
     catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
           error_line++;
           error_column = 0;
        }
        else
           error_column++;
     }
     if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
     }
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
   }
  }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java303
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1306
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6839
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7386
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10029
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12558
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12593
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21574
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22114
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22171
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22727
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26210
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26271
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26303
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27609
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java424
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7236
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7779
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7868
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16727
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17153
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17622
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17670
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17718
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17785
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18017
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18131
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18202
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18497
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18778
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19320
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19660
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19989
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20312
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20361
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27971
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

/*
SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
void attachLibrary() :
{}
{
	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
}
*/

/**
 * All global definitions of triggers, functions and procedures are evaluated here.
 * Every occurence goes under a new PACKAGE-Node in the XML document.
 * This happens, cause a global "block" does not have a definied start and end token 
 * like a package specification or a package body.
 * Thats why every construct is handled like a new part of the global package.
 * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
 * and slow down the whole parsing.
 * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
 * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
 * choose the correct way on a given base. So we can't negate it easily.
 * On the other hand I could also hold the global state in a global variable. 
 * But this does not seems the correct way to solve the problem, I think.
 *
 * 2006-05-17 - Matthias Hendler - added
 */
  final public ASTGlobal Global() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16093
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36014
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38819
    if (jj_scan_token(43)) return true;
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java11
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java92
	}

	@Override
	public Object visit(ASTInput node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTDDLCommand node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTSqlPlusCommand node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTGlobal node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTBlock node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPackageSpecification node, Object data) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1494
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2110
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3972
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4298
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5329
   if (lexState >= 5 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

protected Token jjFillToken()
{
   final Token t;
   final String curTokenImage;
   final int beginLine;
   final int endLine;
   final int beginColumn;
   final int endColumn;
   String im = jjstrLiteralImages[jjmatchedKind];
   curTokenImage = (im == null) ? input_stream.GetImage() : im;
   beginLine = input_stream.getBeginLine();
   beginColumn = input_stream.getBeginColumn();
   endLine = input_stream.getEndLine();
   endColumn = input_stream.getEndColumn();
   t = Token.newToken(jjmatchedKind, curTokenImage);

   t.beginLine = beginLine;
   t.endLine = endLine;
   t.beginColumn = beginColumn;
   t.endColumn = endColumn;

   return t;
}

int curLexState = 0;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7457
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13825
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16906
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17320
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18282
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18564
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19404
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19760
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21294
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22497
          case DATA:
          case DAY:
          case DISABLE:
          case EDITIONABLE:
          case ELEMENT:
          case ENABLE:
          case ESCAPE:
          case EXCEPT:
          case EXCEPTIONS:
          case EXIT:
          case EXTERNAL:
          case EXTENDS:
          case EXTRACT:
          case FALSE:
          case FINAL:
          case FORCE:
          case FUNCTION:
          case GLOBAL:
          case HASH:
          case HEAP:
          case HOUR:
          case IMMEDIATE:
          case INDICES:
          case INDEXTYPE:
          case INDICATOR:
          case INSTANTIABLE:
          case INTERVAL:
          case INVALIDATE:
          case ISOLATION:
          case JAVA:
          case LEVEL:
          case LIMIT:
          case LOOP:
          case MAP:
          case MAX:
          case MEMBER:
          case MERGE:
          case MIN:
          case MINUTE:
          case MLSLABEL:
          case MODIFY:
          case MOD:
          case MONTH:
          case NATURAL:
          case NEW:
          case NO:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9551
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12759
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13359
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13905
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14211
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16591
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16990
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18366
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18931
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19172
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19484
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19844
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20510
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22335
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22577
          case SECOND:
          case SELF:
          case SET:
          case SPACE:
          case SQL:
          case SQLCODE:
          case SQLERRM:
          case STATIC:
          case SUBTYPE:
          case SUBSTITUTABLE:
          case SUCCESSFUL:
          case SYSDATE:
          case SYS_REFCURSOR:
          case TEMPORARY:
          case TIME:
          case TIMESTAMP:
          case TIMEZONE_REGION:
          case TIMEZONE_ABBR:
          case TIMEZONE_MINUTE:
          case TIMEZONE_HOUR:
          case TRANSACTION:
          case TRUE:
          case TYPE:
          case UNDER:
          case USING:
          case YES:
          case SHOW:
          case A:
          case DOUBLE:
          case DEC:
          case PRECISION:
          case INT:
          case NUMERIC:
          case NCHAR:
          case NVARCHAR2:
          case STRING:
          case UROWID:
          case VARRAY:
          case VARYING:
          case BFILE:
          case BLOB:
          case CLOB:
          case NCLOB:
          case YEAR:
          case LOCAL:
          case ZONE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39880
    for (int i = 0; i < 151; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
          if ((jj_la1_3[i] & (1<<j)) != 0) {
            la1tokens[96+j] = true;
          }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14604
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28738
        jj_la1[170] = jj_gen;
        ;
      }
      jj_consume_token(4);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPipelineStatement PipelineStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java4863
net/sourceforge/pmd/lang/vm/ast/VmParser.java1686
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void IfStatement() throws ParseException {
 /*@bgen(jjtree) IfStatement */
  ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(IF);
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36016
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36017
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36018
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36020
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36022
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36023
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36024
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36025
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36026
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36027
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36029
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36030
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36033
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36034
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36036
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36037
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36038
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36039
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36040
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36044
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36050
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36052
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36053
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36054
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36055
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36056
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36058
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36060
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36062
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36064
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36066
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36067
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36068
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36069
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36070
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36071
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36072
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36073
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36074
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36075
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36076
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36077
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36078
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36084
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36086
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36087
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36088
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java2505
net/sourceforge/pmd/lang/vm/ast/VmParser.java2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Expression syntax follows.
 */
  final public void Expression() throws ParseException {
 /*@bgen(jjtree) Expression */
  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2209
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4405
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5497
       if (jjnewLexState[jjmatchedKind] != -1)
         curLexState = jjnewLexState[jjmatchedKind];
           return matchedToken;
        }
        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
           {
              matchedToken = jjFillToken();
              if (specialToken == null)
                 specialToken = matchedToken;
              else
              {
                 matchedToken.specialToken = specialToken;
                 specialToken = (specialToken.next = matchedToken);
              }
              SkipLexicalActions(matchedToken);
           }
           else
              SkipLexicalActions(null);
         if (jjnewLexState[jjmatchedKind] != -1)
           curLexState = jjnewLexState[jjmatchedKind];
           continue EOFLoop;
        }
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java54
net/sourceforge/pmd/lang/vm/ast/VmParser.java253
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
  }

/**
 * The optional prolog of a JSP, including (xml) declarations and DTD.
 */
  final public void Prolog() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14606
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28740
      }
      jj_consume_token(4);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPipelineStatement PipelineStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20639
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21798
      }
      jj_consume_token(7);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTArgumentList ArgumentList() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38821
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36092
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java824
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8964
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10335
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14435
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21890
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23988
        jj_la1[9] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPackageSpecification PackageSpecification() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28741
      jj_consume_token(4);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPipelineStatement PipelineStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21799
      jj_consume_token(7);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTArgumentList ArgumentList() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38822
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36093
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2505
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6754
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15518
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26754
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29387
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTBlock Block() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38823
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/AbstractJavaNode.java19
net/sourceforge/pmd/lang/jsp/ast/AbstractJspNode.java16
    public AbstractJavaNode(JavaParser parser, int id) {
        super(id);
        this.parser = parser;
    }

    public void jjtOpen() {
	if (beginLine == -1 && parser.token.next != null) {
	    beginLine = parser.token.next.beginLine;
	    beginColumn = parser.token.next.beginColumn;
	}
    }

    public void jjtClose() {
	if (beginLine == -1 && (children == null || children.length == 0)) {
	    beginColumn = parser.token.beginColumn;
	}
	if (beginLine == -1) {
	    beginLine = parser.token.beginLine;
	}
	endLine = parser.token.endLine;
	endColumn = parser.token.endColumn;
    }

    /**
     * Accept the visitor. *
     */
    public Object jjtAccept(JavaParserVisitor visitor, Object data) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9681
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10638
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10938
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11240
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16288
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8966
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29388
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

  final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22758
      Expression();
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38824
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java269
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12908
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28741
      jj_consume_token(0);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java826
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6755
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8966
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10337
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10639
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10939
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11241
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11551
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14371
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16289
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22845
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23990
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26755
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29388
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTBlock Block() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8967
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29389
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

  final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38825
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10677
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39955
net/sourceforge/pmd/lang/vm/ast/VmParser.java3763
    for (int i = 0; i < 72; i++) {
    try {
      JJCalls p = jj_2_rtns[i];
      do {
        if (p.gen > jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
            case 1: jj_3_2(); break;
            case 2: jj_3_3(); break;
            case 3: jj_3_4(); break;
            case 4: jj_3_5(); break;
            case 5: jj_3_6(); break;
            case 6: jj_3_7(); break;
            case 7: jj_3_8(); break;
            case 8: jj_3_9(); break;
            case 9: jj_3_10(); break;
            case 10: jj_3_11(); break;
            case 11: jj_3_12(); break;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java827
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2124
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6316
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6355
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8967
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9683
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10338
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12909
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14438
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14608
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15520
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16395
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20792
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21502
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22759
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22846
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29389
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38826
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36097
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38827
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/ecmascript/rule/EcmascriptRuleChainVisitor.java18
net/sourceforge/pmd/lang/xml/rule/XmlRuleChainVisitor.java16
public class EcmascriptRuleChainVisitor extends AbstractRuleChainVisitor {

    protected void indexNodes(List<Node> nodes, RuleContext ctx) {
	// Visit Nodes in DFS order
	Stack<Node> stack = new Stack<Node>();
	stack.addAll(nodes);
	Collections.reverse(stack);
	while (!stack.isEmpty()) {
	    Node node = stack.pop();
	    indexNode(node);
	    if (node.jjtGetNumChildren() > 0) {
		for (int i = node.jjtGetNumChildren() - 1; i >= 0; i--) {
		    stack.push(node.jjtGetChild(i));
		}
	    }
	}
    }

    protected void visit(Rule rule, Node node, RuleContext ctx) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java424
net/sourceforge/pmd/lang/jsp/ast/JspParser.java879
      }
                  jjtree.closeNodeScope(jjtn000, true);
                  jjtc000 = false;
                 jjtn000.setImage(content.toString());
    } catch (Throwable jjte000) {
            if (jjtc000) {
              jjtree.clearNodeScope(jjtn000);
              jjtc000 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte000;}
            }
            if (jjte000 instanceof ParseException) {
              {if (true) throw (ParseException)jjte000;}
            }
            {if (true) throw (Error)jjte000;}
    } finally {
            if (jjtc000) {
              jjtree.closeNodeScope(jjtn000, true);
            }
    }
  }

  final public String UnparsedText() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java268
net/sourceforge/pmd/lang/vm/ast/VmParser.java252
      }
      jj_consume_token(0);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38828
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36099
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java54
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java269
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java4212
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5913
                                               input_stream.backup(1);
         break;
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

private void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}

}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38829
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36100
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2325
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java4213
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5914
         break;
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

private void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}

}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38830
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36101
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2326
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java4214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4468
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5915
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

private void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}

}
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20757
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTExitStatement ExitStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38831
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36102
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5870
net/sourceforge/pmd/lang/java/ast/JavaParser.java5937
      jj_consume_token(RPAREN);
                                               jjtree.closeNodeScope(jjtn000, true);
                                               jjtc000 = false;
                                              checkForBadAnnotationUsage();
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void MarkerAnnotation() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10755
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1783
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java40044
net/sourceforge/pmd/lang/vm/ast/VmParser.java3781
            case 71: jj_3_72(); break;
          }
        }
        p = p.next;
      } while (p != null);
      } catch(LookaheadSuccess ls) { }
    }
    jj_rescan = false;
  }

  private void jj_save(int index, int xla) {
    JJCalls p = jj_2_rtns[index];
    while (p.gen > jj_gen) {
      if (p.next == null) { p = p.next = new JJCalls(); break; }
      p = p.next;
    }
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  }

  static final class JJCalls {
    int gen;
    Token first;
    int arg;
    JJCalls next;
  }

}
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java54
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12908
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28741
net/sourceforge/pmd/lang/vm/ast/VmParser.java253
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

/*
SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
void attachLibrary() :
{}
{
	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
}
*/

/**
 * All global definitions of triggers, functions and procedures are evaluated here.
 * Every occurence goes under a new PACKAGE-Node in the XML document.
 * This happens, cause a global "block" does not have a definied start and end token 
 * like a package specification or a package body.
 * Thats why every construct is handled like a new part of the global package.
 * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
 * and slow down the whole parsing.
 * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
 * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
 * choose the correct way on a given base. So we can't negate it easily.
 * On the other hand I could also hold the global state in a global variable. 
 * But this does not seems the correct way to solve the problem, I think.
 *
 * 2006-05-17 - Matthias Hendler - added
 */
  final public ASTGlobal Global() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38832
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36103
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3712
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java4813
                  break;
               case 0:
                  if ((0x100000200L & l) != 0L)
                     jjCheckNAddTwoStates(0, 1);
                  break;
               case 1:
                  if (curChar == 35)
                     jjCheckNAddTwoStates(6, 11);
                  break;
               case 3:
                  if (curChar == 32)
                     jjAddStates(115, 116);
                  break;
               case 4:
                  if (curChar == 40 && kind > 15)
                     kind = 15;
                  break;
               case 13:
                  if ((0x3ff200000000000L & l) == 0L)
                     break;
                  if (kind > 68)
                     kind = 68;
                  jjstateSet[jjnewStateCnt++] = 13;
                  break;
               case 14:
                  if (curChar == 46)
                     jjstateSet[jjnewStateCnt++] = 15;
                  break;
               case 16:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java55
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java827
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2124
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6316
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8967
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9683
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10338
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14438
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15520
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22846
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29389
net/sourceforge/pmd/lang/vm/ast/VmParser.java254
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38833
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1650
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2328
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java4216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4470
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5917
  }
}

private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

private void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}

}
FileLine
net/sourceforge/pmd/lang/cpp/ast/Token.java9
net/sourceforge/pmd/lang/java/ast/Token.java9
net/sourceforge/pmd/lang/jsp/ast/Token.java9
net/sourceforge/pmd/lang/plsql/ast/Token.java27
net/sourceforge/pmd/lang/vm/ast/Token.java9
public class Token implements java.io.Serializable {

  /**
   * The version identifier for this Serializable class.
   * Increment only if the <i>serialized</i> form of the
   * class changes.
   */
  private static final long serialVersionUID = 1L;

  /**
   * 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)
    {
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1733
net/sourceforge/pmd/lang/vm/ast/VmParser.java3721
    for (int i = 0; i < 33; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 85; i++) {
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2358
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2440
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3493
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 21 - (jjnewStateCnt = startsAt)))
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38834
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36105
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1227
net/sourceforge/pmd/lang/java/ast/JavaParser.java1884
net/sourceforge/pmd/lang/java/ast/JavaParser.java1971
net/sourceforge/pmd/lang/java/ast/JavaParser.java2151
net/sourceforge/pmd/lang/java/ast/JavaParser.java3982
net/sourceforge/pmd/lang/java/ast/JavaParser.java4283
net/sourceforge/pmd/lang/java/ast/JavaParser.java4360
net/sourceforge/pmd/lang/java/ast/JavaParser.java4468
net/sourceforge/pmd/lang/java/ast/JavaParser.java5205
net/sourceforge/pmd/lang/java/ast/JavaParser.java5827
net/sourceforge/pmd/lang/jsp/ast/JspParser.java190
          jj_la1[37] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5870
net/sourceforge/pmd/lang/java/ast/JavaParser.java5902
net/sourceforge/pmd/lang/java/ast/JavaParser.java5937
      jj_consume_token(RPAREN);
                                               jjtree.closeNodeScope(jjtn000, true);
                                               jjtc000 = false;
                                              checkForBadAnnotationUsage();
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void MarkerAnnotation() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20757
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTExitStatement ExitStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38835
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36106
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java79
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java105
		    addAccess((JavaNameOccurrence)occurrence, inode);
		}
	    }
	}
	return undefinitions;
    }

    private Set<Map<NameDeclaration, List<NameOccurrence>>> collectDeclarations(DataFlowNode inode) {
	Set<Map<NameDeclaration, List<NameOccurrence>>> decls = new HashSet<Map<NameDeclaration, List<NameOccurrence>>>();
	Map<NameDeclaration, List<NameOccurrence>> varDecls;
	for (int i = 0; i < inode.getFlow().size(); i++) {
	    DataFlowNode n = inode.getFlow().get(i);
	    if (n instanceof StartOrEndDataFlowNode) {
		continue;
	    }
	    varDecls = ((JavaNode)n.getNode()).getScope().getDeclarations();
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java238
net/sourceforge/pmd/lang/jsp/ast/JspParser.java57
net/sourceforge/pmd/lang/vm/ast/VmParser.java256
net/sourceforge/pmd/lang/vm/ast/VmParser.java902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
  }

  final public void PackageDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java478
net/sourceforge/pmd/lang/java/ast/JavaParser.java1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java4054
net/sourceforge/pmd/lang/java/ast/JavaParser.java4859
net/sourceforge/pmd/lang/java/ast/JavaParser.java6078
net/sourceforge/pmd/lang/java/ast/JavaParser.java6361
net/sourceforge/pmd/lang/jsp/ast/JspParser.java679
net/sourceforge/pmd/lang/vm/ast/VmParser.java974
net/sourceforge/pmd/lang/vm/ast/VmParser.java1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38836
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31742
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38837
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36108
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java585
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java666
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAlterTypeSpec node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAttributeDeclaration node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTAttribute node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTPragmaClause node, Object data) {
		return visit((PLSQLNode) node, data);
	}

	@Override
	public Object visit(ASTTriggerUnit node, Object data) {
FileLine
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java69
net/sourceforge/pmd/lang/ast/JavaCharStream.java93
        int newbufcolumn[] = new int[bufsize + nextBufExpand];

        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;
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1228
net/sourceforge/pmd/lang/java/ast/JavaParser.java1885
net/sourceforge/pmd/lang/java/ast/JavaParser.java1972
net/sourceforge/pmd/lang/java/ast/JavaParser.java2152
net/sourceforge/pmd/lang/java/ast/JavaParser.java3916
net/sourceforge/pmd/lang/java/ast/JavaParser.java3983
net/sourceforge/pmd/lang/java/ast/JavaParser.java4284
net/sourceforge/pmd/lang/java/ast/JavaParser.java4361
net/sourceforge/pmd/lang/java/ast/JavaParser.java4469
net/sourceforge/pmd/lang/java/ast/JavaParser.java5206
net/sourceforge/pmd/lang/java/ast/JavaParser.java5828
net/sourceforge/pmd/lang/jsp/ast/JspParser.java191
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java2667
net/sourceforge/pmd/lang/java/ast/JavaParser.java2942
        ConditionalExpression();
      } else {
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void ConditionalOrExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38838
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36109
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/dfa/StatementAndBraceFinder.java57
net/sourceforge/pmd/lang/plsql/dfa/StatementAndBraceFinder.java80
            throw new RuntimeException("Can't build a data flow for anything other than a method or a constructor");
        }

        this.dataFlow = new Structure(dataFlowHandler);
        this.dataFlow.createStartNode(node.getBeginLine());
        this.dataFlow.createNewNode(node);

        node.jjtAccept(this, dataFlow);

        this.dataFlow.createEndNode(node.getEndLine());
        if (LOGGER.isLoggable(Level.FINE))
        {
          LOGGER.fine("DataFlow is " + this.dataFlow.dump() ); // @TODO SRT Remove after development  
        }
        Linker linker = new Linker(dataFlowHandler, dataFlow.getBraceStack(), dataFlow.getContinueBreakReturnStack());
        try {
            linker.computePaths();
        } catch (LinkerException e) {
FileLine
net/sourceforge/pmd/lang/plsql/symboltable/LocalScope.java34
net/sourceforge/pmd/lang/plsql/symboltable/MethodScope.java44
    }

    @Override
    public void addDeclaration(NameDeclaration declaration) {
        if (declaration instanceof VariableNameDeclaration && getDeclarations().keySet().contains(declaration)) {
            throw new RuntimeException(declaration + " is already in the symbol table");
        }
        super.addDeclaration(declaration);
    }

    public NameDeclaration findVariableHere(PLSQLNameOccurrence occurrence) {
        if (occurrence.isThisOrSuper() || occurrence.isMethodOrConstructorInvocation()) {
            return null;
        }
        ImageFinderFunction finder = new ImageFinderFunction(occurrence.getImage());
        Applier.apply(finder, getVariableDeclarations().keySet().iterator());
        return finder.getDecl();
    }

    public String toString() {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java478
net/sourceforge/pmd/lang/java/ast/JavaParser.java1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java4054
net/sourceforge/pmd/lang/java/ast/JavaParser.java4859
net/sourceforge/pmd/lang/java/ast/JavaParser.java6078
net/sourceforge/pmd/lang/java/ast/JavaParser.java6361
net/sourceforge/pmd/lang/jsp/ast/JspParser.java679
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1168
net/sourceforge/pmd/lang/vm/ast/VmParser.java974
net/sourceforge/pmd/lang/vm/ast/VmParser.java1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java479
net/sourceforge/pmd/lang/java/ast/JavaParser.java1408
net/sourceforge/pmd/lang/java/ast/JavaParser.java1549
net/sourceforge/pmd/lang/java/ast/JavaParser.java2041
net/sourceforge/pmd/lang/java/ast/JavaParser.java2223
net/sourceforge/pmd/lang/java/ast/JavaParser.java2290
net/sourceforge/pmd/lang/java/ast/JavaParser.java2404
net/sourceforge/pmd/lang/java/ast/JavaParser.java3620
net/sourceforge/pmd/lang/java/ast/JavaParser.java4055
net/sourceforge/pmd/lang/java/ast/JavaParser.java4590
net/sourceforge/pmd/lang/java/ast/JavaParser.java4860
net/sourceforge/pmd/lang/java/ast/JavaParser.java6079
net/sourceforge/pmd/lang/java/ast/JavaParser.java6362
net/sourceforge/pmd/lang/jsp/ast/JspParser.java680
net/sourceforge/pmd/lang/vm/ast/VmParser.java975
net/sourceforge/pmd/lang/vm/ast/VmParser.java1462
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3772
net/sourceforge/pmd/lang/java/ast/JavaParser.java3817
        VariableDeclaratorId();
        jj_consume_token(LAMBDA);
        switch (jj_nt.kind) {
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case DOUBLE:
        case FALSE:
        case FLOAT:
        case INT:
        case LONG:
        case NEW:
        case NULL:
        case SHORT:
        case SUPER:
        case THIS:
        case TRUE:
        case VOID:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case HEX_FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case IDENTIFIER:
        case LPAREN:
        case BANG:
        case TILDE:
        case INCR:
        case DECR:
        case PLUS:
        case MINUS:
          Expression();
          break;
        case LBRACE:
          Block();
          break;
        default:
          jj_la1[97] = jj_gen;
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java287
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2841
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3776
                  jjCheckNAddStates(0, 2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 9:
               case 28:
               case 30:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 79)
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java1241
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3019
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java3168
                  jjCheckNAddTwoStates(0, 1);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
               case 0:
               case 2:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 45)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38839
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/symboltable/JavaNameOccurrence.java67
net/sourceforge/pmd/lang/plsql/symboltable/PLSQLNameOccurrence.java58
    public JavaNode getLocation() {
        return location;
    }

    public boolean isOnRightHandSide() {
	Node node = location.jjtGetParent().jjtGetParent().jjtGetParent();
        return node instanceof ASTExpression && node.jjtGetNumChildren() == 3;
    }


    public boolean isOnLeftHandSide() {
        // I detest this method with every atom of my being
	Node primaryExpression;
        if (location.jjtGetParent() instanceof ASTPrimaryExpression) {
            primaryExpression = location.jjtGetParent().jjtGetParent();
        } else if (location.jjtGetParent().jjtGetParent() instanceof ASTPrimaryExpression) {
            primaryExpression = location.jjtGetParent().jjtGetParent().jjtGetParent();
        } else {
            throw new RuntimeException("Found a NameOccurrence that didn't have an ASTPrimary Expression as parent or grandparent.  Parent = " + location.jjtGetParent() + " and grandparent = " + location.jjtGetParent().jjtGetParent());
FileLine
net/sourceforge/pmd/util/database/DBMSMetadata.java118
net/sourceforge/pmd/util/database/DBMSMetadata.java157
  public DBMSMetadata(String user, String password, DBURI dbURI) throws SQLException, MalformedURLException, ClassNotFoundException
  { 
    this.dburi = dbURI;

    this.returnSourceCodeObjectsStatement = dbURI.getDbType().getProperties().getProperty(GET_SOURCE_OBJECTS_STATEMENT) ; 

    this.returnSourceCodeStatement = dbURI.getDbType().getProperties().getProperty(GET_SOURCE_CODE_STATEMENT) ; 

    this.returnType =  dbURI.getSourceCodeType();

    LOGGER.fine("returnSourceCodeStatement="+returnSourceCodeStatement +", returnType="+returnType);
    
    String driverClass = dbURI.getDriverClass();
    String urlString = dbURI.getURL().toString();
    
    LOGGER.fine("driverClass="+driverClass+", urlString="+urlString);

    Class.forName(driverClass);
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3772
net/sourceforge/pmd/lang/java/ast/JavaParser.java3817
net/sourceforge/pmd/lang/java/ast/JavaParser.java3874
        VariableDeclaratorId();
        jj_consume_token(LAMBDA);
        switch (jj_nt.kind) {
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case DOUBLE:
        case FALSE:
        case FLOAT:
        case INT:
        case LONG:
        case NEW:
        case NULL:
        case SHORT:
        case SUPER:
        case THIS:
        case TRUE:
        case VOID:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case HEX_FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case IDENTIFIER:
        case LPAREN:
        case BANG:
        case TILDE:
        case INCR:
        case DECR:
        case PLUS:
        case MINUS:
          Expression();
          break;
        case LBRACE:
          Block();
          break;
        default:
          jj_la1[97] = jj_gen;
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java1899
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java1983
         return ((jjbitVec29[i2] & l2) != 0L);
      case 49:
         return ((jjbitVec30[i2] & l2) != 0L);
      case 77:
         return ((jjbitVec31[i2] & l2) != 0L);
      case 159:
         return ((jjbitVec32[i2] & l2) != 0L);
      case 164:
         return ((jjbitVec33[i2] & l2) != 0L);
      case 215:
         return ((jjbitVec34[i2] & l2) != 0L);
      case 250:
         return ((jjbitVec35[i2] & l2) != 0L);
      case 251:
         return ((jjbitVec36[i2] & l2) != 0L);
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38840
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36111
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/dfa/StatementAndBraceFinder.java256
net/sourceforge/pmd/lang/plsql/dfa/StatementAndBraceFinder.java579
        LOGGER.finest("pushOnStack CONTINUE_STATEMENT: line " + node.getBeginLine() +", column " + node.getBeginColumn());
        return super.visit(node, data);
    }

    public Object visit(ASTReturnStatement node, Object data) {
        if (!(data instanceof Structure)) {
            return data;
        }
        Structure dataFlow = (Structure) data;
        dataFlow.createNewNode(node);
        dataFlow.pushOnStack(NodeType.RETURN_STATEMENT, dataFlow.getLast());
        LOGGER.finest("pushOnStack RETURN_STATEMENT: line " + node.getBeginLine() +", column " + node.getBeginColumn());
        return super.visit(node, data);
    }

    public Object visit(ASTThrowStatement node, Object data) {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java2707
net/sourceforge/pmd/lang/java/ast/JavaParser.java2745
net/sourceforge/pmd/lang/java/ast/JavaParser.java2783
net/sourceforge/pmd/lang/java/ast/JavaParser.java2821
net/sourceforge/pmd/lang/java/ast/JavaParser.java2859
net/sourceforge/pmd/lang/java/ast/JavaParser.java2910
net/sourceforge/pmd/lang/java/ast/JavaParser.java3003
net/sourceforge/pmd/lang/java/ast/JavaParser.java3056
net/sourceforge/pmd/lang/java/ast/JavaParser.java3107
net/sourceforge/pmd/lang/java/ast/JavaParser.java3162
        ConditionalAndExpression();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void ConditionalAndExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3246
net/sourceforge/pmd/lang/java/ast/JavaParser.java3387
net/sourceforge/pmd/lang/java/ast/JavaParser.java3437
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    }
    }
  }

  final public void PreIncrementExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5450
net/sourceforge/pmd/lang/java/ast/JavaParser.java5668
      Expression();
      jj_consume_token(RPAREN);
      Block();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TryStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38841
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36112
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/AbstractJavaNode.java22
net/sourceforge/pmd/lang/jsp/ast/AbstractJspNode.java19
net/sourceforge/pmd/lang/plsql/ast/AbstractPLSQLNode.java23
    }

    public void jjtOpen() {
	if (beginLine == -1 && parser.token.next != null) {
	    beginLine = parser.token.next.beginLine;
	    beginColumn = parser.token.next.beginColumn;
	}
    }

    public void jjtClose() {
	if (beginLine == -1 && (children == null || children.length == 0)) {
	    beginColumn = parser.token.beginColumn;
	}
	if (beginLine == -1) {
	    beginLine = parser.token.beginLine;
	}
	endLine = parser.token.endLine;
	endColumn = parser.token.endColumn;
    }

    /**
     * Accept the visitor. *
     */
    public Object jjtAccept(JavaParserVisitor visitor, Object data) {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java879
net/sourceforge/pmd/lang/java/ast/JavaParser.java1490
net/sourceforge/pmd/lang/java/ast/JavaParser.java6162
        jj_la1[28] = jj_gen;
        ;
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void EnumConstant() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1653
net/sourceforge/pmd/lang/java/ast/JavaParser.java4160
        jj_la1[49] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FormalParameter() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3382
net/sourceforge/pmd/lang/java/ast/JavaParser.java4759
            jj_la1[84] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
    } catch (Throwable jjte000) {
   if (jjtc000) {
     jjtree.clearNodeScope(jjtn000);
     jjtc000 = false;
   } else {
     jjtree.popNode();
   }
   if (jjte000 instanceof RuntimeException) {
     {if (true) throw (RuntimeException)jjte000;}
   }
   if (jjte000 instanceof ParseException) {
     {if (true) throw (ParseException)jjte000;}
   }
   {if (true) throw (Error)jjte000;}
    } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java4590
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1169
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5387
net/sourceforge/pmd/lang/java/ast/JavaParser.java5737
        jj_la1[133] = jj_gen;
        ;
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ThrowStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20757
net/sourceforge/pmd/lang/vm/ast/VmParser.java890
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38842
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36113
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java1033
net/sourceforge/pmd/lang/vm/ast/VmParser.java1126
        jj_la1[18] = jj_gen;
        ;
      }
      jj_consume_token(RBRACKET);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

/**
 *  supports the [n..m] vector generator for use in
 *  the #foreach() to generate measured ranges w/o
 *  needing explicit support from the app/servlet
 */
  final public void IntegerRange() throws ParseException {
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2522
net/sourceforge/pmd/lang/vm/ast/VmParser.java2620
                          ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
          UnaryExpression();
        } catch (Throwable jjte001) {
                          if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte001;}
                          }
                          {if (true) throw (Error)jjte001;}
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  2);
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
 jjtn000.setComments(token_source.comments);
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java327
net/sourceforge/pmd/lang/java/ast/JavaParser.java5387
net/sourceforge/pmd/lang/java/ast/JavaParser.java5737
        jj_la1[6] = jj_gen;
        ;
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1129
net/sourceforge/pmd/lang/java/ast/JavaParser.java6262
        ClassOrInterfaceBodyDeclaration();
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1227
net/sourceforge/pmd/lang/java/ast/JavaParser.java1884
net/sourceforge/pmd/lang/java/ast/JavaParser.java1971
net/sourceforge/pmd/lang/java/ast/JavaParser.java2151
net/sourceforge/pmd/lang/java/ast/JavaParser.java3537
net/sourceforge/pmd/lang/java/ast/JavaParser.java3982
net/sourceforge/pmd/lang/java/ast/JavaParser.java4283
net/sourceforge/pmd/lang/java/ast/JavaParser.java4360
net/sourceforge/pmd/lang/java/ast/JavaParser.java4468
net/sourceforge/pmd/lang/java/ast/JavaParser.java5205
net/sourceforge/pmd/lang/java/ast/JavaParser.java5827
net/sourceforge/pmd/lang/jsp/ast/JspParser.java190
          jj_la1[37] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java2670
net/sourceforge/pmd/lang/java/ast/JavaParser.java2708
net/sourceforge/pmd/lang/java/ast/JavaParser.java2746
net/sourceforge/pmd/lang/java/ast/JavaParser.java2784
net/sourceforge/pmd/lang/java/ast/JavaParser.java2822
net/sourceforge/pmd/lang/java/ast/JavaParser.java2860
net/sourceforge/pmd/lang/java/ast/JavaParser.java2911
net/sourceforge/pmd/lang/java/ast/JavaParser.java2945
net/sourceforge/pmd/lang/java/ast/JavaParser.java3004
net/sourceforge/pmd/lang/java/ast/JavaParser.java3057
net/sourceforge/pmd/lang/java/ast/JavaParser.java3108
net/sourceforge/pmd/lang/java/ast/JavaParser.java3163
net/sourceforge/pmd/lang/java/ast/JavaParser.java3541
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void ConditionalOrExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java4938
net/sourceforge/pmd/lang/java/ast/JavaParser.java5145
      jj_consume_token(RPAREN);
      Statement();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void DoStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38843
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36114
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31742
net/sourceforge/pmd/lang/vm/ast/VmParser.java902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java280
net/sourceforge/pmd/lang/java/ast/JavaParser.java5419
      Name();
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java478
net/sourceforge/pmd/lang/java/ast/JavaParser.java1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java3243
net/sourceforge/pmd/lang/java/ast/JavaParser.java3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java4054
net/sourceforge/pmd/lang/java/ast/JavaParser.java4859
net/sourceforge/pmd/lang/java/ast/JavaParser.java6078
net/sourceforge/pmd/lang/java/ast/JavaParser.java6361
net/sourceforge/pmd/lang/jsp/ast/JspParser.java679
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1168
net/sourceforge/pmd/lang/vm/ast/VmParser.java974
net/sourceforge/pmd/lang/vm/ast/VmParser.java1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParser.java57
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
net/sourceforge/pmd/lang/vm/ast/VmParser.java256
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java579
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java1350
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2538
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 60)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java664
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java5796
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8817
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9836
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11097
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27795
        case RETURN:
        case RETURNING:
        case REVERSE:
        case ROLLBACK:
        case ROW:
        case ROWS:
        case ROWID:
        case ROWNUM:
        case SAVE:
        case SAVEPOINT:
        case SECOND:
        case SELECT:
        case SELF:
        case SET:
        case SPACE:
        case SQL:
        case SQLCODE:
        case SQLERRM:
        case STATIC:
        case SUBTYPE:
        case SUBSTITUTABLE:
        case SUCCESSFUL:
        case SYSDATE:
        case SYS_REFCURSOR:
        case TEMPORARY:
        case TIME:
        case TIMESTAMP:
        case TIMEZONE_REGION:
        case TIMEZONE_ABBR:
        case TIMEZONE_MINUTE:
        case TIMEZONE_HOUR:
        case TRANSACTION:
        case TRUE:
        case TYPE:
        case UNDER:
        case USING:
        case WHILE:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38844
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36115
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java280
net/sourceforge/pmd/lang/java/ast/JavaParser.java4972
net/sourceforge/pmd/lang/java/ast/JavaParser.java5419
      Name();
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java881
net/sourceforge/pmd/lang/java/ast/JavaParser.java1130
net/sourceforge/pmd/lang/java/ast/JavaParser.java1492
net/sourceforge/pmd/lang/java/ast/JavaParser.java4818
net/sourceforge/pmd/lang/java/ast/JavaParser.java6164
net/sourceforge/pmd/lang/java/ast/JavaParser.java6263
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void EnumConstant() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1273
net/sourceforge/pmd/lang/java/ast/JavaParser.java5389
net/sourceforge/pmd/lang/java/ast/JavaParser.java5739
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void VariableDeclarator() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1655
net/sourceforge/pmd/lang/java/ast/JavaParser.java4162
net/sourceforge/pmd/lang/java/ast/JavaParser.java5544
      }
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FormalParameter() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java10632
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1733
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39880
net/sourceforge/pmd/lang/vm/ast/VmParser.java3721
    for (int i = 0; i < 151; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38845
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java852
net/sourceforge/pmd/lang/vm/ast/VmParser.java1663
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
      jj_consume_token(END);
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java1684
net/sourceforge/pmd/lang/vm/ast/VmParser.java1808
      }
      jj_consume_token(END);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

  final public void IfStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/ASTFormalParameter.java31
net/sourceforge/pmd/lang/java/ast/ASTLocalVariableDeclaration.java24
    public Object jjtAccept(JavaParserVisitor visitor, Object data) {
        return visitor.visit(this, data);
    }

    public boolean hasSuppressWarningsAnnotationFor(Rule rule) {
        for (int i = 0; i < jjtGetNumChildren(); i++) {
            if (jjtGetChild(i) instanceof ASTAnnotation) {
                ASTAnnotation a = (ASTAnnotation) jjtGetChild(i);
                if (a.suppresses(rule)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean isArray() {
        return checkType() + checkDecl() > 0;
    }

    public int getArrayDepth() {
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java281
net/sourceforge/pmd/lang/java/ast/JavaParser.java1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java4973
net/sourceforge/pmd/lang/java/ast/JavaParser.java5390
net/sourceforge/pmd/lang/java/ast/JavaParser.java5420
net/sourceforge/pmd/lang/java/ast/JavaParser.java5740
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java329
net/sourceforge/pmd/lang/java/ast/JavaParser.java1273
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java707
net/sourceforge/pmd/lang/java/ast/JavaParser.java1062
        ClassOrInterfaceType();
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void EnumDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java925
net/sourceforge/pmd/lang/java/ast/JavaParser.java1019
net/sourceforge/pmd/lang/java/ast/JavaParser.java1309
net/sourceforge/pmd/lang/java/ast/JavaParser.java5507
net/sourceforge/pmd/lang/vm/ast/VmParser.java2054
        jj_la1[30] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TypeParameters() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java2097
net/sourceforge/pmd/lang/jsp/ast/JspParser.java427
net/sourceforge/pmd/lang/jsp/ast/JspParser.java882
   jjtn000.setImage(s.toString());
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TypeArguments() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3274
net/sourceforge/pmd/lang/java/ast/JavaParser.java3303
      jj_consume_token(INCR);
      PrimaryExpression();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void PreDecrementExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3538
net/sourceforge/pmd/lang/java/ast/JavaParser.java3916
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java4502
net/sourceforge/pmd/lang/java/ast/JavaParser.java4938
net/sourceforge/pmd/lang/java/ast/JavaParser.java5145
      jj_consume_token(COLON);
      Statement();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void Block() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5451
net/sourceforge/pmd/lang/java/ast/JavaParser.java5669
net/sourceforge/pmd/lang/java/ast/JavaParser.java5698
      jj_consume_token(RPAREN);
      Block();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TryStatement() throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java27973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java31742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java32061
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38846
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36117
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java281
net/sourceforge/pmd/lang/java/ast/JavaParser.java330
net/sourceforge/pmd/lang/java/ast/JavaParser.java4973
net/sourceforge/pmd/lang/java/ast/JavaParser.java5420
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java480
net/sourceforge/pmd/lang/java/ast/JavaParser.java707
net/sourceforge/pmd/lang/java/ast/JavaParser.java1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java1409
net/sourceforge/pmd/lang/java/ast/JavaParser.java1550
net/sourceforge/pmd/lang/java/ast/JavaParser.java1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java2042
net/sourceforge/pmd/lang/java/ast/JavaParser.java2224
net/sourceforge/pmd/lang/java/ast/JavaParser.java2291
net/sourceforge/pmd/lang/java/ast/JavaParser.java2405
net/sourceforge/pmd/lang/java/ast/JavaParser.java2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java3621
net/sourceforge/pmd/lang/java/ast/JavaParser.java4056
net/sourceforge/pmd/lang/java/ast/JavaParser.java4203
net/sourceforge/pmd/lang/java/ast/JavaParser.java4544
net/sourceforge/pmd/lang/java/ast/JavaParser.java4591
net/sourceforge/pmd/lang/java/ast/JavaParser.java4658
net/sourceforge/pmd/lang/java/ast/JavaParser.java4861
net/sourceforge/pmd/lang/java/ast/JavaParser.java5249
net/sourceforge/pmd/lang/java/ast/JavaParser.java5582
net/sourceforge/pmd/lang/java/ast/JavaParser.java5980
net/sourceforge/pmd/lang/java/ast/JavaParser.java6080
net/sourceforge/pmd/lang/java/ast/JavaParser.java6363
net/sourceforge/pmd/lang/jsp/ast/JspParser.java681
net/sourceforge/pmd/lang/vm/ast/VmParser.java976
net/sourceforge/pmd/lang/vm/ast/VmParser.java1463
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1229
net/sourceforge/pmd/lang/java/ast/JavaParser.java1886
net/sourceforge/pmd/lang/java/ast/JavaParser.java1973
net/sourceforge/pmd/lang/java/ast/JavaParser.java2153
net/sourceforge/pmd/lang/java/ast/JavaParser.java3917
net/sourceforge/pmd/lang/java/ast/JavaParser.java3984
net/sourceforge/pmd/lang/java/ast/JavaParser.java4285
net/sourceforge/pmd/lang/java/ast/JavaParser.java4362
net/sourceforge/pmd/lang/java/ast/JavaParser.java4470
net/sourceforge/pmd/lang/java/ast/JavaParser.java5207
net/sourceforge/pmd/lang/java/ast/JavaParser.java5829
net/sourceforge/pmd/lang/jsp/ast/JspParser.java192
net/sourceforge/pmd/lang/vm/ast/VmParser.java1892
net/sourceforge/pmd/lang/vm/ast/VmParser.java1988
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java5452
net/sourceforge/pmd/lang/java/ast/JavaParser.java5670
net/sourceforge/pmd/lang/java/ast/JavaParser.java5699
      Block();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Type, name and expression syntax follows.
 */
  final public void Type() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3244
net/sourceforge/pmd/lang/java/ast/JavaParser.java4590
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java3740
net/sourceforge/pmd/lang/java/ast/JavaParser.java4762
          }
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void LambdaExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java579
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java1350
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java1531
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java2538
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 60)
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java7503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java10143
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java12724
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13055
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13325
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java13871
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java14176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16556
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java16955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java17368
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18331
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java18896
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19137
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19450
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java19809
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java20475
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java21340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22301
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java22543
          case NONEDITIONABLE:
          case NULLIF:
          case OBJECT:
          case OID:
          case OPAQUE:
          case OPEN:
          case OPERATOR:
          case ORGANIZATION:
          case OTHERS:
          case OVERRIDING:
          case PACKAGE:
          case PARTITION:
          case PRESERVE:
          case PRIVATE:
          case PROCEDURE:
          case RANGE:
          case RAW:
          case REAL:
          case RECORD:
          case REF:
          case RELEASE:
          case RELIES_ON:
          case RENAME:
          case RESULT:
          case RETURN:
          case RETURNING:
          case REVERSE:
          case ROLLBACK:
          case ROW:
          case ROWS:
          case ROWID:
          case ROWNUM:
          case SAVE:
          case SAVEPOINT:
          case SECOND:
          case SELF:
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38847
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36118
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2158
net/sourceforge/pmd/lang/vm/ast/VmParser.java2198
        ConditionalAndExpression();
      } catch (Throwable jjte001) {
                     if (jjtc001) {
                       jjtree.clearNodeScope(jjtn001);
                       jjtc001 = false;
                     } else {
                       jjtree.popNode();
                     }
                     if (jjte001 instanceof RuntimeException) {
                       {if (true) throw (RuntimeException)jjte001;}
                     }
                     if (jjte001 instanceof ParseException) {
                       {if (true) throw (ParseException)jjte001;}
                     }
                     {if (true) throw (Error)jjte001;}
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  2);
                     }
      }
    }
  }

  final public void ConditionalAndExpression() throws ParseException {
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2268
net/sourceforge/pmd/lang/vm/ast/VmParser.java2476
          RelationalExpression();
        } catch (Throwable jjte002) {
                              if (jjtc002) {
                                jjtree.clearNodeScope(jjtn002);
                                jjtc002 = false;
                              } else {
                                jjtree.popNode();
                              }
                              if (jjte002 instanceof RuntimeException) {
                                {if (true) throw (RuntimeException)jjte002;}
                              }
                              if (jjte002 instanceof ParseException) {
                                {if (true) throw (ParseException)jjte002;}
                              }
                              {if (true) throw (Error)jjte002;}
        } finally {
                              if (jjtc002) {
                                jjtree.closeNodeScope(jjtn002,  2);
                              }
        }
        break;
      default:
        jj_la1[62] = jj_gen;
FileLine
net/sourceforge/pmd/lang/ast/JavaCharStream.java348
net/sourceforge/pmd/lang/ast/SimpleCharStream.java202
  }

  @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,
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java480
net/sourceforge/pmd/lang/java/ast/JavaParser.java707
net/sourceforge/pmd/lang/java/ast/JavaParser.java1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java1409
net/sourceforge/pmd/lang/java/ast/JavaParser.java1550
net/sourceforge/pmd/lang/java/ast/JavaParser.java1595
net/sourceforge/pmd/lang/java/ast/JavaParser.java1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java2042
net/sourceforge/pmd/lang/java/ast/JavaParser.java2224
net/sourceforge/pmd/lang/java/ast/JavaParser.java2291
net/sourceforge/pmd/lang/java/ast/JavaParser.java2405
net/sourceforge/pmd/lang/java/ast/JavaParser.java2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java3621
net/sourceforge/pmd/lang/java/ast/JavaParser.java4056
net/sourceforge/pmd/lang/java/ast/JavaParser.java4203
net/sourceforge/pmd/lang/java/ast/JavaParser.java4544
net/sourceforge/pmd/lang/java/ast/JavaParser.java4591
net/sourceforge/pmd/lang/java/ast/JavaParser.java4658
net/sourceforge/pmd/lang/java/ast/JavaParser.java4861
net/sourceforge/pmd/lang/java/ast/JavaParser.java5249
net/sourceforge/pmd/lang/java/ast/JavaParser.java5582
net/sourceforge/pmd/lang/java/ast/JavaParser.java5980
net/sourceforge/pmd/lang/java/ast/JavaParser.java6080
net/sourceforge/pmd/lang/java/ast/JavaParser.java6363
net/sourceforge/pmd/lang/jsp/ast/JspParser.java681
net/sourceforge/pmd/lang/vm/ast/VmParser.java976
net/sourceforge/pmd/lang/vm/ast/VmParser.java1463
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java571
net/sourceforge/pmd/lang/java/ast/JavaParser.java755
net/sourceforge/pmd/lang/java/ast/JavaParser.java1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java4503
net/sourceforge/pmd/lang/java/ast/JavaParser.java4939
net/sourceforge/pmd/lang/java/ast/JavaParser.java5146
net/sourceforge/pmd/lang/java/ast/JavaParser.java5278
net/sourceforge/pmd/lang/java/ast/JavaParser.java5452
net/sourceforge/pmd/lang/java/ast/JavaParser.java5638
net/sourceforge/pmd/lang/java/ast/JavaParser.java5670
net/sourceforge/pmd/lang/java/ast/JavaParser.java5699
net/sourceforge/pmd/lang/java/ast/JavaParser.java5873
net/sourceforge/pmd/lang/java/ast/JavaParser.java5905
net/sourceforge/pmd/lang/java/ast/JavaParser.java5940
net/sourceforge/pmd/lang/java/ast/JavaParser.java6012
net/sourceforge/pmd/lang/java/ast/JavaParser.java6199
net/sourceforge/pmd/lang/jsp/ast/JspParser.java713
net/sourceforge/pmd/lang/vm/ast/VmParser.java2089
      ClassOrInterfaceBody();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ExtendsList() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1230
net/sourceforge/pmd/lang/java/ast/JavaParser.java1887
net/sourceforge/pmd/lang/java/ast/JavaParser.java1974
net/sourceforge/pmd/lang/java/ast/JavaParser.java2154
net/sourceforge/pmd/lang/java/ast/JavaParser.java3741
net/sourceforge/pmd/lang/java/ast/JavaParser.java3918
net/sourceforge/pmd/lang/java/ast/JavaParser.java3985
net/sourceforge/pmd/lang/java/ast/JavaParser.java4286
net/sourceforge/pmd/lang/java/ast/JavaParser.java4363
net/sourceforge/pmd/lang/java/ast/JavaParser.java4471
net/sourceforge/pmd/lang/java/ast/JavaParser.java4763
net/sourceforge/pmd/lang/java/ast/JavaParser.java5208
net/sourceforge/pmd/lang/java/ast/JavaParser.java5830
net/sourceforge/pmd/lang/jsp/ast/JspParser.java193
net/sourceforge/pmd/lang/vm/ast/VmParser.java1893
net/sourceforge/pmd/lang/vm/ast/VmParser.java1989
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36119
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38848
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1658
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java1869
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2074
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java2703
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3224
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java3456
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5173
                     jjAddStates(98, 99);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java281
net/sourceforge/pmd/lang/java/ast/JavaParser.java571
net/sourceforge/pmd/lang/java/ast/JavaParser.java755
net/sourceforge/pmd/lang/java/ast/JavaParser.java882
net/sourceforge/pmd/lang/java/ast/JavaParser.java971
net/sourceforge/pmd/lang/java/ast/JavaParser.java1131
net/sourceforge/pmd/lang/java/ast/JavaParser.java1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java1493
net/sourceforge/pmd/lang/java/ast/JavaParser.java1656
net/sourceforge/pmd/lang/java/ast/JavaParser.java1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java2097
net/sourceforge/pmd/lang/java/ast/JavaParser.java3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java4163
net/sourceforge/pmd/lang/java/ast/JavaParser.java4503
net/sourceforge/pmd/lang/java/ast/JavaParser.java4819
net/sourceforge/pmd/lang/java/ast/JavaParser.java4939
net/sourceforge/pmd/lang/java/ast/JavaParser.java4973
net/sourceforge/pmd/lang/java/ast/JavaParser.java5146
net/sourceforge/pmd/lang/java/ast/JavaParser.java5278
net/sourceforge/pmd/lang/java/ast/JavaParser.java5390
net/sourceforge/pmd/lang/java/ast/JavaParser.java5420
net/sourceforge/pmd/lang/java/ast/JavaParser.java5452
net/sourceforge/pmd/lang/java/ast/JavaParser.java5545
net/sourceforge/pmd/lang/java/ast/JavaParser.java5638
net/sourceforge/pmd/lang/java/ast/JavaParser.java5670
net/sourceforge/pmd/lang/java/ast/JavaParser.java5699
net/sourceforge/pmd/lang/java/ast/JavaParser.java5740
net/sourceforge/pmd/lang/java/ast/JavaParser.java5873
net/sourceforge/pmd/lang/java/ast/JavaParser.java5905
net/sourceforge/pmd/lang/java/ast/JavaParser.java5940
net/sourceforge/pmd/lang/java/ast/JavaParser.java6012
net/sourceforge/pmd/lang/java/ast/JavaParser.java6165
net/sourceforge/pmd/lang/java/ast/JavaParser.java6199
net/sourceforge/pmd/lang/java/ast/JavaParser.java6264
net/sourceforge/pmd/lang/java/ast/JavaParser.java6408
net/sourceforge/pmd/lang/jsp/ast/JspParser.java277
net/sourceforge/pmd/lang/jsp/ast/JspParser.java713
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1001
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1058
net/sourceforge/pmd/lang/vm/ast/VmParser.java1036
net/sourceforge/pmd/lang/vm/ast/VmParser.java1129
net/sourceforge/pmd/lang/vm/ast/VmParser.java1301
net/sourceforge/pmd/lang/vm/ast/VmParser.java1331
net/sourceforge/pmd/lang/vm/ast/VmParser.java1685
net/sourceforge/pmd/lang/vm/ast/VmParser.java1809
net/sourceforge/pmd/lang/vm/ast/VmParser.java2089
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java481
net/sourceforge/pmd/lang/java/ast/JavaParser.java640
net/sourceforge/pmd/lang/java/ast/JavaParser.java708
net/sourceforge/pmd/lang/java/ast/JavaParser.java927
net/sourceforge/pmd/lang/java/ast/JavaParser.java1021
net/sourceforge/pmd/lang/java/ast/JavaParser.java1063
net/sourceforge/pmd/lang/java/ast/JavaParser.java1231
net/sourceforge/pmd/lang/java/ast/JavaParser.java1311
net/sourceforge/pmd/lang/java/ast/JavaParser.java1410
net/sourceforge/pmd/lang/java/ast/JavaParser.java1551
net/sourceforge/pmd/lang/java/ast/JavaParser.java1596
net/sourceforge/pmd/lang/java/ast/JavaParser.java1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java1888
net/sourceforge/pmd/lang/java/ast/JavaParser.java1975
net/sourceforge/pmd/lang/java/ast/JavaParser.java2043
net/sourceforge/pmd/lang/java/ast/JavaParser.java2155
net/sourceforge/pmd/lang/java/ast/JavaParser.java2225
net/sourceforge/pmd/lang/java/ast/JavaParser.java2292
net/sourceforge/pmd/lang/java/ast/JavaParser.java2406
net/sourceforge/pmd/lang/java/ast/JavaParser.java2505
net/sourceforge/pmd/lang/java/ast/JavaParser.java2542
net/sourceforge/pmd/lang/java/ast/JavaParser.java3578
net/sourceforge/pmd/lang/java/ast/JavaParser.java3622
net/sourceforge/pmd/lang/java/ast/JavaParser.java3742
net/sourceforge/pmd/lang/java/ast/JavaParser.java3919
net/sourceforge/pmd/lang/java/ast/JavaParser.java3986
net/sourceforge/pmd/lang/java/ast/JavaParser.java4057
net/sourceforge/pmd/lang/java/ast/JavaParser.java4204
net/sourceforge/pmd/lang/java/ast/JavaParser.java4287
net/sourceforge/pmd/lang/java/ast/JavaParser.java4364
net/sourceforge/pmd/lang/java/ast/JavaParser.java4472
net/sourceforge/pmd/lang/java/ast/JavaParser.java4544
net/sourceforge/pmd/lang/java/ast/JavaParser.java4592
net/sourceforge/pmd/lang/java/ast/JavaParser.java4659
net/sourceforge/pmd/lang/java/ast/JavaParser.java4764
net/sourceforge/pmd/lang/java/ast/JavaParser.java4862
net/sourceforge/pmd/lang/java/ast/JavaParser.java5209
net/sourceforge/pmd/lang/java/ast/JavaParser.java5250
net/sourceforge/pmd/lang/java/ast/JavaParser.java5509
net/sourceforge/pmd/lang/java/ast/JavaParser.java5583
net/sourceforge/pmd/lang/java/ast/JavaParser.java5831
net/sourceforge/pmd/lang/java/ast/JavaParser.java5981
net/sourceforge/pmd/lang/java/ast/JavaParser.java6081
net/sourceforge/pmd/lang/java/ast/JavaParser.java6364
net/sourceforge/pmd/lang/jsp/ast/JspParser.java194
net/sourceforge/pmd/lang/jsp/ast/JspParser.java682
net/sourceforge/pmd/lang/vm/ast/VmParser.java977
net/sourceforge/pmd/lang/vm/ast/VmParser.java1464
net/sourceforge/pmd/lang/vm/ast/VmParser.java1894
net/sourceforge/pmd/lang/vm/ast/VmParser.java1990
net/sourceforge/pmd/lang/vm/ast/VmParser.java2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java838
net/sourceforge/pmd/lang/java/ast/JavaParser.java1092
        label_14:
        while (true) {
          switch (jj_nt.kind) {
          case ABSTRACT:
          case BOOLEAN:
          case BYTE:
          case CHAR:
          case CLASS:
          case _DEFAULT:
          case DOUBLE:
          case FINAL:
          case FLOAT:
          case INT:
          case INTERFACE:
          case LONG:
          case NATIVE:
          case PRIVATE:
          case PROTECTED:
          case PUBLIC:
          case SHORT:
          case STATIC:
          case SYNCHRONIZED:
          case TRANSIENT:
          case VOID:
          case VOLATILE:
          case STRICTFP:
          case IDENTIFIER:
          case LBRACE:
          case SEMICOLON:
          case AT:
          case LT:
            ;
            break;
          default:
            jj_la1[27] = jj_gen;
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java6011
net/sourceforge/pmd/lang/java/ast/JavaParser.java6436
      jj_consume_token(ASSIGN);
      MemberValue();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36120
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38849
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java852
net/sourceforge/pmd/lang/vm/ast/VmParser.java1663
net/sourceforge/pmd/lang/vm/ast/VmParser.java1760
net/sourceforge/pmd/lang/vm/ast/VmParser.java1873
net/sourceforge/pmd/lang/vm/ast/VmParser.java1969
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java281
net/sourceforge/pmd/lang/java/ast/JavaParser.java1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java4973
net/sourceforge/pmd/lang/java/ast/JavaParser.java5390
net/sourceforge/pmd/lang/java/ast/JavaParser.java5420
net/sourceforge/pmd/lang/java/ast/JavaParser.java5740
net/sourceforge/pmd/lang/jsp/ast/JspParser.java427
net/sourceforge/pmd/lang/jsp/ast/JspParser.java882
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java282
net/sourceforge/pmd/lang/java/ast/JavaParser.java482
net/sourceforge/pmd/lang/java/ast/JavaParser.java572
net/sourceforge/pmd/lang/java/ast/JavaParser.java641
net/sourceforge/pmd/lang/java/ast/JavaParser.java709
net/sourceforge/pmd/lang/java/ast/JavaParser.java756
net/sourceforge/pmd/lang/java/ast/JavaParser.java883
net/sourceforge/pmd/lang/java/ast/JavaParser.java928
net/sourceforge/pmd/lang/java/ast/JavaParser.java972
net/sourceforge/pmd/lang/java/ast/JavaParser.java1022
net/sourceforge/pmd/lang/java/ast/JavaParser.java1064
net/sourceforge/pmd/lang/java/ast/JavaParser.java1132
net/sourceforge/pmd/lang/java/ast/JavaParser.java1232
net/sourceforge/pmd/lang/java/ast/JavaParser.java1275
net/sourceforge/pmd/lang/java/ast/JavaParser.java1312
net/sourceforge/pmd/lang/java/ast/JavaParser.java1411
net/sourceforge/pmd/lang/java/ast/JavaParser.java1494
net/sourceforge/pmd/lang/java/ast/JavaParser.java1552
net/sourceforge/pmd/lang/java/ast/JavaParser.java1597
net/sourceforge/pmd/lang/java/ast/JavaParser.java1657
net/sourceforge/pmd/lang/java/ast/JavaParser.java1735
net/sourceforge/pmd/lang/java/ast/JavaParser.java1801
net/sourceforge/pmd/lang/java/ast/JavaParser.java1889
net/sourceforge/pmd/lang/java/ast/JavaParser.java1926
net/sourceforge/pmd/lang/java/ast/JavaParser.java1976
net/sourceforge/pmd/lang/java/ast/JavaParser.java2044
net/sourceforge/pmd/lang/java/ast/JavaParser.java2098
net/sourceforge/pmd/lang/java/ast/JavaParser.java2156
net/sourceforge/pmd/lang/java/ast/JavaParser.java2226
net/sourceforge/pmd/lang/java/ast/JavaParser.java2293
net/sourceforge/pmd/lang/java/ast/JavaParser.java2407
net/sourceforge/pmd/lang/java/ast/JavaParser.java2506
net/sourceforge/pmd/lang/java/ast/JavaParser.java2543
net/sourceforge/pmd/lang/java/ast/JavaParser.java3276
net/sourceforge/pmd/lang/java/ast/JavaParser.java3305
net/sourceforge/pmd/lang/java/ast/JavaParser.java3579
net/sourceforge/pmd/lang/java/ast/JavaParser.java3623
net/sourceforge/pmd/lang/java/ast/JavaParser.java3743
net/sourceforge/pmd/lang/java/ast/JavaParser.java3920
net/sourceforge/pmd/lang/java/ast/JavaParser.java3987
net/sourceforge/pmd/lang/java/ast/JavaParser.java4058
net/sourceforge/pmd/lang/java/ast/JavaParser.java4164
net/sourceforge/pmd/lang/java/ast/JavaParser.java4205
net/sourceforge/pmd/lang/java/ast/JavaParser.java4288
net/sourceforge/pmd/lang/java/ast/JavaParser.java4365
net/sourceforge/pmd/lang/java/ast/JavaParser.java4473
net/sourceforge/pmd/lang/java/ast/JavaParser.java4504
net/sourceforge/pmd/lang/java/ast/JavaParser.java4545
net/sourceforge/pmd/lang/java/ast/JavaParser.java4593
net/sourceforge/pmd/lang/java/ast/JavaParser.java4660
net/sourceforge/pmd/lang/java/ast/JavaParser.java4765
net/sourceforge/pmd/lang/java/ast/JavaParser.java4820
net/sourceforge/pmd/lang/java/ast/JavaParser.java4863
net/sourceforge/pmd/lang/java/ast/JavaParser.java4908
net/sourceforge/pmd/lang/java/ast/JavaParser.java4940
net/sourceforge/pmd/lang/java/ast/JavaParser.java4974
net/sourceforge/pmd/lang/java/ast/JavaParser.java5147
net/sourceforge/pmd/lang/java/ast/JavaParser.java5210
net/sourceforge/pmd/lang/java/ast/JavaParser.java5251
net/sourceforge/pmd/lang/java/ast/JavaParser.java5279
net/sourceforge/pmd/lang/java/ast/JavaParser.java5391
net/sourceforge/pmd/lang/java/ast/JavaParser.java5421
net/sourceforge/pmd/lang/java/ast/JavaParser.java5453
net/sourceforge/pmd/lang/java/ast/JavaParser.java5510
net/sourceforge/pmd/lang/java/ast/JavaParser.java5546
net/sourceforge/pmd/lang/java/ast/JavaParser.java5584
net/sourceforge/pmd/lang/java/ast/JavaParser.java5639
net/sourceforge/pmd/lang/java/ast/JavaParser.java5671
net/sourceforge/pmd/lang/java/ast/JavaParser.java5700
net/sourceforge/pmd/lang/java/ast/JavaParser.java5741
net/sourceforge/pmd/lang/java/ast/JavaParser.java5832
net/sourceforge/pmd/lang/java/ast/JavaParser.java5874
net/sourceforge/pmd/lang/java/ast/JavaParser.java5906
net/sourceforge/pmd/lang/java/ast/JavaParser.java5941
net/sourceforge/pmd/lang/java/ast/JavaParser.java5982
net/sourceforge/pmd/lang/java/ast/JavaParser.java6013
net/sourceforge/pmd/lang/java/ast/JavaParser.java6082
net/sourceforge/pmd/lang/java/ast/JavaParser.java6166
net/sourceforge/pmd/lang/java/ast/JavaParser.java6200
net/sourceforge/pmd/lang/java/ast/JavaParser.java6265
net/sourceforge/pmd/lang/java/ast/JavaParser.java6365
net/sourceforge/pmd/lang/java/ast/JavaParser.java6409
net/sourceforge/pmd/lang/jsp/ast/JspParser.java195
net/sourceforge/pmd/lang/jsp/ast/JspParser.java278
net/sourceforge/pmd/lang/jsp/ast/JspParser.java683
net/sourceforge/pmd/lang/jsp/ast/JspParser.java714
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1002
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1059
net/sourceforge/pmd/lang/vm/ast/VmParser.java978
net/sourceforge/pmd/lang/vm/ast/VmParser.java1037
net/sourceforge/pmd/lang/vm/ast/VmParser.java1130
net/sourceforge/pmd/lang/vm/ast/VmParser.java1302
net/sourceforge/pmd/lang/vm/ast/VmParser.java1332
net/sourceforge/pmd/lang/vm/ast/VmParser.java1465
net/sourceforge/pmd/lang/vm/ast/VmParser.java1686
net/sourceforge/pmd/lang/vm/ast/VmParser.java1810
net/sourceforge/pmd/lang/vm/ast/VmParser.java1895
net/sourceforge/pmd/lang/vm/ast/VmParser.java1991
net/sourceforge/pmd/lang/vm/ast/VmParser.java2057
net/sourceforge/pmd/lang/vm/ast/VmParser.java2090
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java330
net/sourceforge/pmd/lang/java/ast/JavaParser.java571
net/sourceforge/pmd/lang/java/ast/JavaParser.java755
net/sourceforge/pmd/lang/java/ast/JavaParser.java882
net/sourceforge/pmd/lang/java/ast/JavaParser.java971
net/sourceforge/pmd/lang/java/ast/JavaParser.java1131
net/sourceforge/pmd/lang/java/ast/JavaParser.java1493
net/sourceforge/pmd/lang/java/ast/JavaParser.java1656
net/sourceforge/pmd/lang/java/ast/JavaParser.java1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java2097
net/sourceforge/pmd/lang/java/ast/JavaParser.java3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java4163
net/sourceforge/pmd/lang/java/ast/JavaParser.java4503
net/sourceforge/pmd/lang/java/ast/JavaParser.java4819
net/sourceforge/pmd/lang/java/ast/JavaParser.java4939
net/sourceforge/pmd/lang/java/ast/JavaParser.java5146
net/sourceforge/pmd/lang/java/ast/JavaParser.java5278
net/sourceforge/pmd/lang/java/ast/JavaParser.java5452
net/sourceforge/pmd/lang/java/ast/JavaParser.java5545
net/sourceforge/pmd/lang/java/ast/JavaParser.java5638
net/sourceforge/pmd/lang/java/ast/JavaParser.java5670
net/sourceforge/pmd/lang/java/ast/JavaParser.java5699
net/sourceforge/pmd/lang/java/ast/JavaParser.java5873
net/sourceforge/pmd/lang/java/ast/JavaParser.java5905
net/sourceforge/pmd/lang/java/ast/JavaParser.java5940
net/sourceforge/pmd/lang/java/ast/JavaParser.java6012
net/sourceforge/pmd/lang/java/ast/JavaParser.java6165
net/sourceforge/pmd/lang/java/ast/JavaParser.java6199
net/sourceforge/pmd/lang/java/ast/JavaParser.java6264
net/sourceforge/pmd/lang/java/ast/JavaParser.java6408
net/sourceforge/pmd/lang/jsp/ast/JspParser.java277
net/sourceforge/pmd/lang/jsp/ast/JspParser.java713
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1001
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1058
net/sourceforge/pmd/lang/vm/ast/VmParser.java1036
net/sourceforge/pmd/lang/vm/ast/VmParser.java1129
net/sourceforge/pmd/lang/vm/ast/VmParser.java1301
net/sourceforge/pmd/lang/vm/ast/VmParser.java1331
net/sourceforge/pmd/lang/vm/ast/VmParser.java1685
net/sourceforge/pmd/lang/vm/ast/VmParser.java1809
net/sourceforge/pmd/lang/vm/ast/VmParser.java2089
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java481
net/sourceforge/pmd/lang/java/ast/JavaParser.java640
net/sourceforge/pmd/lang/java/ast/JavaParser.java708
net/sourceforge/pmd/lang/java/ast/JavaParser.java927
net/sourceforge/pmd/lang/java/ast/JavaParser.java1021
net/sourceforge/pmd/lang/java/ast/JavaParser.java1063
net/sourceforge/pmd/lang/java/ast/JavaParser.java1231
net/sourceforge/pmd/lang/java/ast/JavaParser.java1311
net/sourceforge/pmd/lang/java/ast/JavaParser.java1410
net/sourceforge/pmd/lang/java/ast/JavaParser.java1551
net/sourceforge/pmd/lang/java/ast/JavaParser.java1596
net/sourceforge/pmd/lang/java/ast/JavaParser.java1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java1888
net/sourceforge/pmd/lang/java/ast/JavaParser.java1975
net/sourceforge/pmd/lang/java/ast/JavaParser.java2043
net/sourceforge/pmd/lang/java/ast/JavaParser.java2155
net/sourceforge/pmd/lang/java/ast/JavaParser.java2225
net/sourceforge/pmd/lang/java/ast/JavaParser.java2292
net/sourceforge/pmd/lang/java/ast/JavaParser.java2406
net/sourceforge/pmd/lang/java/ast/JavaParser.java2505
net/sourceforge/pmd/lang/java/ast/JavaParser.java2542
net/sourceforge/pmd/lang/java/ast/JavaParser.java3578
net/sourceforge/pmd/lang/java/ast/JavaParser.java3622
net/sourceforge/pmd/lang/java/ast/JavaParser.java3742
net/sourceforge/pmd/lang/java/ast/JavaParser.java3919
net/sourceforge/pmd/lang/java/ast/JavaParser.java3986
net/sourceforge/pmd/lang/java/ast/JavaParser.java4057
net/sourceforge/pmd/lang/java/ast/JavaParser.java4204
net/sourceforge/pmd/lang/java/ast/JavaParser.java4287
net/sourceforge/pmd/lang/java/ast/JavaParser.java4364
net/sourceforge/pmd/lang/java/ast/JavaParser.java4472
net/sourceforge/pmd/lang/java/ast/JavaParser.java4544
net/sourceforge/pmd/lang/java/ast/JavaParser.java4592
net/sourceforge/pmd/lang/java/ast/JavaParser.java4659
net/sourceforge/pmd/lang/java/ast/JavaParser.java4764
net/sourceforge/pmd/lang/java/ast/JavaParser.java4862
net/sourceforge/pmd/lang/java/ast/JavaParser.java5209
net/sourceforge/pmd/lang/java/ast/JavaParser.java5250
net/sourceforge/pmd/lang/java/ast/JavaParser.java5509
net/sourceforge/pmd/lang/java/ast/JavaParser.java5583
net/sourceforge/pmd/lang/java/ast/JavaParser.java5831
net/sourceforge/pmd/lang/java/ast/JavaParser.java5981
net/sourceforge/pmd/lang/java/ast/JavaParser.java6081
net/sourceforge/pmd/lang/java/ast/JavaParser.java6364
net/sourceforge/pmd/lang/jsp/ast/JspParser.java194
net/sourceforge/pmd/lang/jsp/ast/JspParser.java682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29433
net/sourceforge/pmd/lang/vm/ast/VmParser.java977
net/sourceforge/pmd/lang/vm/ast/VmParser.java1464
net/sourceforge/pmd/lang/vm/ast/VmParser.java1894
net/sourceforge/pmd/lang/vm/ast/VmParser.java1990
net/sourceforge/pmd/lang/vm/ast/VmParser.java2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java707
net/sourceforge/pmd/lang/java/ast/JavaParser.java1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java4203
net/sourceforge/pmd/lang/java/ast/JavaParser.java4544
net/sourceforge/pmd/lang/java/ast/JavaParser.java4658
net/sourceforge/pmd/lang/java/ast/JavaParser.java5249
net/sourceforge/pmd/lang/java/ast/JavaParser.java5582
net/sourceforge/pmd/lang/java/ast/JavaParser.java5980
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1170
        ClassOrInterfaceType();
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4330
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5361
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

/** Get the next Token. */
public Token getNextToken() 
{
  Token specialToken = null;
  Token matchedToken;
  int curPos = 0;

  EOFLoop :
  for (;;)
  {
   try
   {
      curChar = input_stream.BeginToken();
   }
   catch(java.io.IOException e)
   {
      jjmatchedKind = 0;
      matchedToken = jjFillToken();
      matchedToken.specialToken = specialToken;
      return matchedToken;
   }
   image = jjimage;
   image.setLength(0);
   jjimageLen = 0;

   for (;;)
   {
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38850
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5244
"\52", "\74\74", "\76\76", "\75\76", "\50\52\51", null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2241
net/sourceforge/pmd/lang/vm/ast/VmParser.java2319
net/sourceforge/pmd/lang/vm/ast/VmParser.java2449
net/sourceforge/pmd/lang/vm/ast/VmParser.java2526
          RelationalExpression();
        } catch (Throwable jjte001) {
                          if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte001;}
                          }
                          {if (true) throw (Error)jjte001;}
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  2);
                          }
        }
        break;
      case LOGICAL_NOT_EQUALS:
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2346
net/sourceforge/pmd/lang/vm/ast/VmParser.java2553
          AdditiveExpression();
        } catch (Throwable jjte002) {
                        if (jjtc002) {
                          jjtree.clearNodeScope(jjtn002);
                          jjtc002 = false;
                        } else {
                          jjtree.popNode();
                        }
                        if (jjte002 instanceof RuntimeException) {
                          {if (true) throw (RuntimeException)jjte002;}
                        }
                        if (jjte002 instanceof ParseException) {
                          {if (true) throw (ParseException)jjte002;}
                        }
                        {if (true) throw (Error)jjte002;}
        } finally {
                        if (jjtc002) {
                          jjtree.closeNodeScope(jjtn002,  2);
                        }
        }
        break;
      case LOGICAL_LE:
FileLine
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5269
   -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java238
net/sourceforge/pmd/lang/jsp/ast/JspParser.java57
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java32061
net/sourceforge/pmd/lang/vm/ast/VmParser.java256
net/sourceforge/pmd/lang/vm/ast/VmParser.java902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java282
net/sourceforge/pmd/lang/java/ast/JavaParser.java572
net/sourceforge/pmd/lang/java/ast/JavaParser.java756
net/sourceforge/pmd/lang/java/ast/JavaParser.java883
net/sourceforge/pmd/lang/java/ast/JavaParser.java972
net/sourceforge/pmd/lang/java/ast/JavaParser.java1132
net/sourceforge/pmd/lang/java/ast/JavaParser.java1275
net/sourceforge/pmd/lang/java/ast/JavaParser.java1494
net/sourceforge/pmd/lang/java/ast/JavaParser.java1657
net/sourceforge/pmd/lang/java/ast/JavaParser.java1735
net/sourceforge/pmd/lang/java/ast/JavaParser.java1926
net/sourceforge/pmd/lang/java/ast/JavaParser.java2098
net/sourceforge/pmd/lang/java/ast/JavaParser.java3276
net/sourceforge/pmd/lang/java/ast/JavaParser.java3305
net/sourceforge/pmd/lang/java/ast/JavaParser.java4164
net/sourceforge/pmd/lang/java/ast/JavaParser.java4504
net/sourceforge/pmd/lang/java/ast/JavaParser.java4820
net/sourceforge/pmd/lang/java/ast/JavaParser.java4940
net/sourceforge/pmd/lang/java/ast/JavaParser.java4974
net/sourceforge/pmd/lang/java/ast/JavaParser.java5147
net/sourceforge/pmd/lang/java/ast/JavaParser.java5279
net/sourceforge/pmd/lang/java/ast/JavaParser.java5391
net/sourceforge/pmd/lang/java/ast/JavaParser.java5421
net/sourceforge/pmd/lang/java/ast/JavaParser.java5453
net/sourceforge/pmd/lang/java/ast/JavaParser.java5546
net/sourceforge/pmd/lang/java/ast/JavaParser.java5639
net/sourceforge/pmd/lang/java/ast/JavaParser.java5671
net/sourceforge/pmd/lang/java/ast/JavaParser.java5700
net/sourceforge/pmd/lang/java/ast/JavaParser.java5741
net/sourceforge/pmd/lang/java/ast/JavaParser.java5874
net/sourceforge/pmd/lang/java/ast/JavaParser.java5906
net/sourceforge/pmd/lang/java/ast/JavaParser.java5941
net/sourceforge/pmd/lang/java/ast/JavaParser.java6013
net/sourceforge/pmd/lang/java/ast/JavaParser.java6166
net/sourceforge/pmd/lang/java/ast/JavaParser.java6200
net/sourceforge/pmd/lang/java/ast/JavaParser.java6265
net/sourceforge/pmd/lang/java/ast/JavaParser.java6409
net/sourceforge/pmd/lang/jsp/ast/JspParser.java278
net/sourceforge/pmd/lang/jsp/ast/JspParser.java714
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1002
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java29434
net/sourceforge/pmd/lang/vm/ast/VmParser.java1037
net/sourceforge/pmd/lang/vm/ast/VmParser.java1130
net/sourceforge/pmd/lang/vm/ast/VmParser.java1302
net/sourceforge/pmd/lang/vm/ast/VmParser.java1332
net/sourceforge/pmd/lang/vm/ast/VmParser.java1686
net/sourceforge/pmd/lang/vm/ast/VmParser.java1810
net/sourceforge/pmd/lang/vm/ast/VmParser.java2090
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java331
net/sourceforge/pmd/lang/java/ast/JavaParser.java482
net/sourceforge/pmd/lang/java/ast/JavaParser.java641
net/sourceforge/pmd/lang/java/ast/JavaParser.java709
net/sourceforge/pmd/lang/java/ast/JavaParser.java928
net/sourceforge/pmd/lang/java/ast/JavaParser.java1022
net/sourceforge/pmd/lang/java/ast/JavaParser.java1064
net/sourceforge/pmd/lang/java/ast/JavaParser.java1232
net/sourceforge/pmd/lang/java/ast/JavaParser.java1312
net/sourceforge/pmd/lang/java/ast/JavaParser.java1411
net/sourceforge/pmd/lang/java/ast/JavaParser.java1552
net/sourceforge/pmd/lang/java/ast/JavaParser.java1597
net/sourceforge/pmd/lang/java/ast/JavaParser.java1801
net/sourceforge/pmd/lang/java/ast/JavaParser.java1889
net/sourceforge/pmd/lang/java/ast/JavaParser.java1976
net/sourceforge/pmd/lang/java/ast/JavaParser.java2044
net/sourceforge/pmd/lang/java/ast/JavaParser.java2156
net/sourceforge/pmd/lang/java/ast/JavaParser.java2226
net/sourceforge/pmd/lang/java/ast/JavaParser.java2293
net/sourceforge/pmd/lang/java/ast/JavaParser.java2407
net/sourceforge/pmd/lang/java/ast/JavaParser.java2506
net/sourceforge/pmd/lang/java/ast/JavaParser.java2543
net/sourceforge/pmd/lang/java/ast/JavaParser.java3579
net/sourceforge/pmd/lang/java/ast/JavaParser.java3623
net/sourceforge/pmd/lang/java/ast/JavaParser.java3743
net/sourceforge/pmd/lang/java/ast/JavaParser.java3920
net/sourceforge/pmd/lang/java/ast/JavaParser.java3987
net/sourceforge/pmd/lang/java/ast/JavaParser.java4058
net/sourceforge/pmd/lang/java/ast/JavaParser.java4205
net/sourceforge/pmd/lang/java/ast/JavaParser.java4288
net/sourceforge/pmd/lang/java/ast/JavaParser.java4365
net/sourceforge/pmd/lang/java/ast/JavaParser.java4473
net/sourceforge/pmd/lang/java/ast/JavaParser.java4545
net/sourceforge/pmd/lang/java/ast/JavaParser.java4593
net/sourceforge/pmd/lang/java/ast/JavaParser.java4660
net/sourceforge/pmd/lang/java/ast/JavaParser.java4765
net/sourceforge/pmd/lang/java/ast/JavaParser.java4863
net/sourceforge/pmd/lang/java/ast/JavaParser.java4908
net/sourceforge/pmd/lang/java/ast/JavaParser.java5210
net/sourceforge/pmd/lang/java/ast/JavaParser.java5251
net/sourceforge/pmd/lang/java/ast/JavaParser.java5510
net/sourceforge/pmd/lang/java/ast/JavaParser.java5584
net/sourceforge/pmd/lang/java/ast/JavaParser.java5832
net/sourceforge/pmd/lang/java/ast/JavaParser.java5982
net/sourceforge/pmd/lang/java/ast/JavaParser.java6082
net/sourceforge/pmd/lang/java/ast/JavaParser.java6365
net/sourceforge/pmd/lang/jsp/ast/JspParser.java195
net/sourceforge/pmd/lang/jsp/ast/JspParser.java428
net/sourceforge/pmd/lang/jsp/ast/JspParser.java683
net/sourceforge/pmd/lang/jsp/ast/JspParser.java883
net/sourceforge/pmd/lang/vm/ast/VmParser.java978
net/sourceforge/pmd/lang/vm/ast/VmParser.java1465
net/sourceforge/pmd/lang/vm/ast/VmParser.java1895
net/sourceforge/pmd/lang/vm/ast/VmParser.java1991
net/sourceforge/pmd/lang/vm/ast/VmParser.java2057
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java571
net/sourceforge/pmd/lang/java/ast/JavaParser.java755
net/sourceforge/pmd/lang/java/ast/JavaParser.java1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java4503
net/sourceforge/pmd/lang/java/ast/JavaParser.java4939
net/sourceforge/pmd/lang/java/ast/JavaParser.java5146
net/sourceforge/pmd/lang/java/ast/JavaParser.java5278
net/sourceforge/pmd/lang/java/ast/JavaParser.java5452
net/sourceforge/pmd/lang/java/ast/JavaParser.java5638
net/sourceforge/pmd/lang/java/ast/JavaParser.java5670
net/sourceforge/pmd/lang/java/ast/JavaParser.java5699
net/sourceforge/pmd/lang/java/ast/JavaParser.java5873
net/sourceforge/pmd/lang/java/ast/JavaParser.java5905
net/sourceforge/pmd/lang/java/ast/JavaParser.java5940
net/sourceforge/pmd/lang/java/ast/JavaParser.java6199
net/sourceforge/pmd/lang/java/ast/JavaParser.java6437
net/sourceforge/pmd/lang/jsp/ast/JspParser.java713
net/sourceforge/pmd/lang/vm/ast/VmParser.java2089
      ClassOrInterfaceBody();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1229
net/sourceforge/pmd/lang/java/ast/JavaParser.java1886
net/sourceforge/pmd/lang/java/ast/JavaParser.java1973
net/sourceforge/pmd/lang/java/ast/JavaParser.java2153
net/sourceforge/pmd/lang/java/ast/JavaParser.java3917
net/sourceforge/pmd/lang/java/ast/JavaParser.java3984
net/sourceforge/pmd/lang/java/ast/JavaParser.java4285
net/sourceforge/pmd/lang/java/ast/JavaParser.java4362
net/sourceforge/pmd/lang/java/ast/JavaParser.java4470
net/sourceforge/pmd/lang/java/ast/JavaParser.java5207
net/sourceforge/pmd/lang/java/ast/JavaParser.java5829
net/sourceforge/pmd/lang/jsp/ast/JspParser.java192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java32060
net/sourceforge/pmd/lang/vm/ast/VmParser.java1892
net/sourceforge/pmd/lang/vm/ast/VmParser.java1988
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java1595
net/sourceforge/pmd/lang/jsp/ast/JspParser.java1170
        jj_consume_token(RBRACKET);
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java5070
net/sourceforge/pmd/lang/java/ast/JavaParser.java5354
          jj_consume_token(SEMICOLON);
          switch (jj_nt.kind) {
          case BOOLEAN:
          case BYTE:
          case CHAR:
          case DOUBLE:
          case FALSE:
          case FLOAT:
          case INT:
          case LONG:
          case NEW:
          case NULL:
          case SHORT:
          case SUPER:
          case THIS:
          case TRUE:
          case VOID:
          case INTEGER_LITERAL:
          case FLOATING_POINT_LITERAL:
          case HEX_FLOATING_POINT_LITERAL:
          case CHARACTER_LITERAL:
          case STRING_LITERAL:
          case IDENTIFIER:
          case LPAREN:
          case BANG:
          case TILDE:
          case INCR:
          case DECR:
          case PLUS:
          case MINUS:
            Expression();
            break;
          default:
            jj_la1[126] = jj_gen;
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java36122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java38851
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
FileLine
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2268
net/sourceforge/pmd/lang/vm/ast/VmParser.java2346
net/sourceforge/pmd/lang/vm/ast/VmParser.java2476
net/sourceforge/pmd/lang/vm/ast/VmParser.java2553
          RelationalExpression();
        } catch (Throwable jjte002) {
                              if (jjtc002) {
                                jjtree.clearNodeScope(jjtn002);
                                jjtc002 = false;
                              } else {
                                jjtree.popNode();
                              }
                              if (jjte002 instanceof RuntimeException) {
                                {if (true) throw (RuntimeException)jjte002;}
                              }
                              if (jjte002 instanceof ParseException) {
                                {if (true) throw (ParseException)jjte002;}
                              }
                              {if (true) throw (Error)jjte002;}
        } finally {
                              if (jjtc002) {
                                jjtree.closeNodeScope(jjtn002,  2);
                              }
        }
        break;
FileLine
net/sourceforge/pmd/lang/vm/ast/VmParser.java2373
net/sourceforge/pmd/lang/vm/ast/VmParser.java2580
          AdditiveExpression();
        } catch (Throwable jjte003) {
                        if (jjtc003) {
                          jjtree.clearNodeScope(jjtn003);
                          jjtc003 = false;
                        } else {
                          jjtree.popNode();
                        }
                        if (jjte003 instanceof RuntimeException) {
                          {if (true) throw (RuntimeException)jjte003;}
                        }
                        if (jjte003 instanceof ParseException) {
                          {if (true) throw (ParseException)jjte003;}
                        }
                        {if (true) throw (Error)jjte003;}
        } finally {
                        if (jjtc003) {
                          jjtree.closeNodeScope(jjtn003,  2);
                        }
        }
        break;