CPD Results

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

Duplications

FileLine
net/sourceforge/pmd/lang/java/ast/JavaParser.java6461
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_2_73(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_73(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(72, xla); }
  }

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

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

    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/java/ast/JavaParser.java10749
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java39955
    for (int i = 0; i < 74; 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;
            case 72: jj_3_73(); break;
            case 73: jj_3_74(); break;
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/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.java6460
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.java10595
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.java10657
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