CPD Results

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

Duplications

File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 32082
  }

  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_2_75(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_75(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(74, xla); }
  }

  private boolean jj_3R_219() {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserVisitorAdapter.java 10
net/sourceforge/pmd/lang/java/rule/AbstractJavaRule.java 75
    }

    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) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java 65
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java 149
		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) {
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserVisitorAdapter.java 5
net/sourceforge/pmd/lang/vm/rule/AbstractVmRule.java 81
    @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);
    }

}
File Line
net/sourceforge/pmd/lang/ecmascript/ast/EcmascriptParserVisitorAdapter.java 8
net/sourceforge/pmd/lang/ecmascript/rule/AbstractEcmascriptRule.java 104
    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);
    }
}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2891
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4328
        }
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20859
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26349
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3978
      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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25376
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25738
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5947
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23629
          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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24585
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25376
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25738
          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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1690
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23631
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28393
        }
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28394
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28395
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4329
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28394
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24586
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25377
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25739
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27080
            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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26352
                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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1691
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6872
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28394
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25741
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28395
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6873
                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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2914
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5352
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3978
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24236
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3262
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4329
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1693
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4876
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6874
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20863
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23634
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24589
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25380
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28396
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28869
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3978
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24236
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28004
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24238
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28006
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
            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);
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8420
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8694
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10974
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11274
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11606
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11918
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15239
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27672
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1410
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5674
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14678
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23356
      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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1412
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10375
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10675
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11277
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11921
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12233
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14962
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23358
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27675
        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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 548
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1416
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8701
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10679
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11925
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14966
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15246
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27679
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3284
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5352
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24260
            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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28028
            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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14094
      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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20393
      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:
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1616
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3604
    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];
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18253
        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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18535
      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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31313
  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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19061
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19374
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13524
      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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13797
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7430
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13525
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13798
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19377
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20395
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22231
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22473
        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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22471
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13801
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19380
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22231
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31012
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31313
  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:
File Line
net/sourceforge/pmd/lang/java/ast/ParseException.java 14
net/sourceforge/pmd/lang/jsp/ast/ParseException.java 14
net/sourceforge/pmd/lang/plsql/ast/ParseException.java 32
net/sourceforge/pmd/lang/vm/ast/ParseException.java 14
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();
   }

}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3339
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24315
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28083
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10772
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39955
    for (int i = 0; i < 75; 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;
            case 74: jj_3_75(); break;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14149
      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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20448
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1781
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1986
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2615
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)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1781
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1986
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2615
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5085
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; }
   }
}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19782
      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:
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6462
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2727
    }
  }

  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) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2156
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3261
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25740
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28005
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2891
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4328
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4874
        }
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 32082
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2728
  }

  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) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3262
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4329
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25741
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28395
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2158
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24239
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28007
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28869
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10062
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12974
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16475
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16874
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20394
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28565
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserVisitorAdapter.java 8
net/sourceforge/pmd/lang/jsp/rule/AbstractJspRule.java 66
    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);
    }
}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16476
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19729
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20397
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19134
      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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18893
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 71
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2625
                     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)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16555
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19136
        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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16555
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18895
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 75
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2629
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3574
                  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)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4897
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23655
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25401
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25763
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28890
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16580
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17392
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18355
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18920
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19161
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JJTJavaParserState.java 14
net/sourceforge/pmd/lang/jsp/ast/JJTJspParserState.java 14
net/sourceforge/pmd/lang/plsql/ast/JJTPLSQLParserState.java 14
net/sourceforge/pmd/lang/vm/ast/JJTVmParserState.java 14
  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;
    }
  }
}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2197
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5485
         }
         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 :
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java 615
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java 703
		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);
        }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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 = {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10618
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39771
    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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21267
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22470
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19378
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21268
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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 = {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22231
      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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12697
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16529
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18304
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13920
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22350
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22592
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29038
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39833
    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];
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2328
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4151
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29038
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29038
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1030
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1769
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6950
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20939
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23710
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24665
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25456
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25818
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27159
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28472
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28945
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java 456
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 405
        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];
    }

}
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15758
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java 524
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java 603
	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) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 709
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1577
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2792
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3511
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10840
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11442
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11774
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12086
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12398
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14845
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23523
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27840
        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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 311
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2865
                  jjCheckNAddStates(0, 2);
                  break;
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(3, 6);
                  break;
               case 3:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(16, 17);
                  break;
               case 6:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(18, 19);
                  break;
               case 11:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(7, 10);
                  break;
               case 13:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(20, 21);
                  break;
               case 16:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(22, 23);
                  break;
               case 21:
               case 23:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(11, 13);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
private int jjMoveStringLiteralDfa0_5()
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4298
   if (lexState >= 3 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

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

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

   return t;
}

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

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

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

   for (;;)
   {
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
         break;
       case 1:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_1();
         if (jjmatchedPos == 0 && jjmatchedKind > 11)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3141
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4578
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5579
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10210
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14243
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17022
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23261
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12723
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13054
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19808
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20474
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10686
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39839
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3680
  }

  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];
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1201
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9583
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16623
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17435
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18398
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18679
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18963
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24487
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24836
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25989
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26600
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27330
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28643
        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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15922
      case VARYING:
      case BFILE:
      case BLOB:
      case CLOB:
      case NCLOB:
      case YEAR:
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
        Datatype();
        break;
      default:
        jj_la1[72] = jj_gen;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18532
        simpleNode = UnaryExpression(false);
                                            sb.append(simpleNode.getImage());
        break;
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
      case NO:
      case NONEDITIONABLE:
      case NOT:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7572
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21408
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22370
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31149
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31450
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3805
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 4893
               case 33:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  else if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 2:
                  if ((0x10000000100000L & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 5:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 6:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  break;
               case 7:
                  if (curChar == 125)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 8:
                  if ((0x10000000100000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 7;
                  break;
               case 9:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 8;
                  break;
               case 10:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 9;
                  break;
               case 11:
                  if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 13:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 68)
                     kind = 68;
                  jjCheckNAdd(13);
                  break;
               case 15:
                  if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
                     kind = 69;
                  break;
               case 17:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2406
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3141
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4578
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5579
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19876
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23261
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18818
        simpleNode = UnaryExpression(false);
                                            sb.append(simpleNode.getImage());
        break;
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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 = {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18253
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20397
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19060
      switch (jj_nt.kind) {
      case 5:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDICES:
      case INDEXTYPE:
      case INDICATOR:
      case INSTANTIABLE:
      case INTERVAL:
      case INVALIDATE:
      case ISOLATION:
      case JAVA:
      case LEVEL:
      case LIMIT:
      case LOOP:
      case MAP:
      case MAX:
      case MEMBER:
      case MERGE:
      case MIN:
      case MINUTE:
      case MLSLABEL:
      case MODIFY:
      case MOD:
      case MONTH:
      case NATURAL:
      case NEW:
      case NEW_DOT:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28273
          case BEFORE:
          case OLD:
          case PARENT:
          case ANALYZE:
          case ASSOCIATE:
          case AUDIT:
          case COMPOUND:
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            ;
            break;
          default:
            jj_la1[345] = jj_gen;
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 311
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2865
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3800
                  jjCheckNAddStates(0, 2);
                  break;
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(3, 6);
                  break;
               case 3:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(16, 17);
                  break;
               case 6:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(18, 19);
                  break;
               case 11:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(7, 10);
                  break;
               case 13:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(20, 21);
                  break;
               case 16:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(22, 23);
                  break;
               case 21:
               case 23:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(11, 13);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3154
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3873
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4591
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23274
        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:
File Line
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java 103
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java 130
	if (occurrence.isOnLeftHandSide()) {
	    this.addVariableAccess(occurrence.getLocation(), new VariableAccess(VariableAccess.DEFINITION, occurrence
		    .getImage()), inode.getFlow());
	} else if (occurrence.isOnRightHandSide() || !occurrence.isOnLeftHandSide() && !occurrence.isOnRightHandSide()) {
	    this.addVariableAccess(occurrence.getLocation(), new VariableAccess(VariableAccess.REFERENCING, occurrence
		    .getImage()), inode.getFlow());
	}
    }

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

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

}
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1438
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2047
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4224
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4226
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4227
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12804
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13135
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14256
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20555
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
      case IDENTIFIER:
      case QUOTED_LITERAL:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7581
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22621
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23894
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28656
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1957
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7138
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23898
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24853
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26617
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27347
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28660
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18820
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19061
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28275
        case CC_IF:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case QUOTED_LITERAL:
        case SQLDATA_CLASS:
        case CUSTOMDATUM_CLASS:
        case ORADATA_CLASS:
        case JAVA_INTERFACE_CLASS:
          ;
          break;
        default:
          jj_la1[33] = jj_gen;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7581
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9596
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13676
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17448
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18411
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18976
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19528
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22379
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22621
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16877
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19731
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20397
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5136
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9596
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16636
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17448
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18411
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18692
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18976
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23894
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26613
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28656
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30515
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31158
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31459
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28662
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14263
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
        case IDENTIFIER:
        case UNSIGNED_NUMERIC_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case QUOTED_LITERAL:
          Expression();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java 471
net/sourceforge/pmd/lang/ast/JavaCharStream.java 564
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 418
        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];
    }

}
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19223
        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();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27861
        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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/vm/util/VelocityCharStream.java 69
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 43
        int newbufcolumn[] = new int[bufsize + nextBufExpand];

        try
        {
            if (wrapAround)
            {
                System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
                System.arraycopy(buffer, 0, newbuffer,
                        bufsize - tokenBegin, bufpos);
                buffer = newbuffer;

                System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
                System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
                bufline = newbufline;

                System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
                System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
                bufcolumn = newbufcolumn;

                maxNextCharInd = (bufpos += (bufsize - tokenBegin));
            }
            else
            {
                System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
                buffer = newbuffer;

                System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
                bufline = newbufline;

                System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
                bufcolumn = newbufcolumn;

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


        bufsize += nextBufExpand;
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7585
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13407
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13680
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13953
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21421
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22383
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22625
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28273
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5337
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23020
            case LANGUAGE:
            case INLINE:
            case ADD:
            case AGGREGATE:
            case ALL:
            case ALTER:
            case AND:
            case ANY:
            case ARRAY:
            case AS:
            case ASC:
            case AT:
            case ATTRIBUTE:
            case AUTHID:
            case AVG:
            case BEGIN:
            case BETWEEN:
            case BINARY_INTEGER:
            case BODY:
            case BOOLEAN:
            case BULK:
            case BY:
            case BYTE:
            case CASCADE:
            case CASE:
            case CHAR:
            case CHAR_BASE:
            case CHECK:
            case CLOSE:
            case CLUSTER:
            case COALESCE:
            case COLLECT:
            case COLUMN:
            case COMMENT:
            case COMMIT:
            case COMPRESS:
            case CONNECT:
            case CONSTANT:
            case CONSTRUCTOR:
            case CONTINUE:
            case CONVERT:
            case CREATE:
            case CURRENT:
            case CURRVAL:
            case CURSOR:
            case DATA:
            case DATE:
            case DAY:
            case DECLARE:
            case DECIMAL:
            case _DEFAULT:
            case DELETE:
            case DESC:
            case DISABLE:
            case DISTINCT:
            case DO:
            case DROP:
            case EDITIONABLE:
            case ELEMENT:
            case ELSE:
            case ELSIF:
            case ENABLE:
            case ESCAPE:
            case EXCEPT:
            case EXCEPTION:
            case EXCEPTIONS:
            case EXCLUSIVE:
            case EXECUTE:
            case EXISTS:
            case EXIT:
            case EXTERNAL:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9600
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17452
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18415
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18696
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19221
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28273
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/ast/TokenMgrError.java 50
net/sourceforge/pmd/lang/java/ast/ParseException.java 141
net/sourceforge/pmd/lang/jsp/ast/ParseException.java 141
net/sourceforge/pmd/lang/plsql/ast/ParseException.java 159
net/sourceforge/pmd/lang/vm/ast/ParseException.java 141
  protected static final String addEscapes(String str) {
    StringBuffer retval = new StringBuffer();
    char ch;
    for (int i = 0; i < str.length(); i++) {
      switch (str.charAt(i))
      {
        case 0 :
          continue;
        case '\b':
          retval.append("\\b");
          continue;
        case '\t':
          retval.append("\\t");
          continue;
        case '\n':
          retval.append("\\n");
          continue;
        case '\f':
          retval.append("\\f");
          continue;
        case '\r':
          retval.append("\\r");
          continue;
        case '\"':
          retval.append("\\\"");
          continue;
        case '\'':
          retval.append("\\\'");
          continue;
        case '\\':
          retval.append("\\\\");
          continue;
        default:
          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
            String s = "0000" + Integer.toString(ch, 16);
            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
          } else {
            retval.append(ch);
          }
          continue;
      }
    }
    return retval.toString();
  }
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28662
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23281
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31162
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31463
        case INSTEADOF:
        case OLD:
        case PARENT:
        case ANALYZE:
        case ASSOCIATE:
        case AUDIT:
        case COMPOUND:
        case DATABASE:
        case CALL:
        case DDL:
        case DISASSOCIATE:
        case EACH:
        case FOLLOWS:
        case LOGOFF:
        case LOGON:
        case NESTED:
        case NOAUDIT:
        case SCHEMA:
        case SERVERERROR:
        case SHUTDOWN:
        case STARTUP:
        case STATEMENT:
        case STATISTICS:
        case SUSPEND:
        case TRUNCATE:
        case WRAPPED:
        case LIBRARY:
        case NAME:
        case STRUCT:
        case CONTEXT:
        case PARAMETERS:
        case LENGTH:
        case TDO:
        case MAXLEN:
        case CHARSETID:
        case CHARSETFORM:
        case ACCEPT:
        case ACCESSIBLE:
        case COPY:
        case DEFINE:
        case DISCONNECT:
        case HOST:
        case PRINT:
        case QUIT:
        case REMARK:
        case UNDEFINE:
        case VARIABLE:
        case WHENEVER:
        case ATTACH:
        case CAST:
        case TREAT:
        case TRIM:
        case LEFT:
        case RIGHT:
        case BOTH:
        case EMPTY:
        case MULTISET:
        case SUBMULTISET:
        case LEADING:
        case TRAILING:
        case CHAR_CS:
        case NCHAR_CS:
        case DBTIMEZONE:
        case SESSIONTIMEZONE:
        case AUTHENTICATED:
        case LINK:
        case SHARED:
        case DIRECTORY:
        case USER:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case DBTIMEZONE:
          case SESSIONTIMEZONE:
          case AUTHENTICATED:
          case LINK:
          case SHARED:
          case DIRECTORY:
          case USER:
          case IDENTIFIER:
          case QUOTED_LITERAL:
          case SQLDATA_CLASS:
          case CUSTOMDATUM_CLASS:
          case ORADATA_CLASS:
          case JAVA_INTERFACE_CLASS:
            if (jj_2_75(2)) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28662
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1873
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1969
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void ElseIfStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1225
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1964
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2431
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2818
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3166
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3885
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4603
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5147
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5604
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7145
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21134
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23286
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23905
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24511
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24860
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25651
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26013
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28280
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
        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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15928
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19889
      case LOCAL:
      case ZONE:
      case CHARACTER:
      case AFTER:
      case BEFORE:
      case OLD:
      case PARENT:
      case CC_IF:
      case ANALYZE:
      case ASSOCIATE:
      case AUDIT:
      case COMPOUND:
      case DATABASE:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3161
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3880
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5599
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6605
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12811
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14263
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15935
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20562
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23281
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31164
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31465
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4430
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5522
      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)
   {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13414
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13960
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22390
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
      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:
File Line
net/sourceforge/pmd/lang/ast/JavaCharStream.java 83
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 32
  protected int inBuf = 0;
  protected int tabSize = 8;

  protected void setTabSize(int i) { tabSize = i; }
  protected int getTabSize(int i) { return tabSize; }

  protected void ExpandBuff(boolean wrapAround)
  {
    char[] newbuffer = new char[bufsize + 2048];
    int newbufline[] = new int[bufsize + 2048];
    int newbufcolumn[] = new int[bufsize + 2048];

    try
    {
      if (wrapAround)
      {
        System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
        System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
        buffer = newbuffer;

        System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
        System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
        bufline = newbufline;

        System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
        System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
        bufcolumn = newbufcolumn;
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 735
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1603
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5867
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8614
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8888
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9907
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10235
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10566
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11168
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11468
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12112
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12424
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12816
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13147
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14268
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14871
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15153
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15433
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17459
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18422
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18987
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20567
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10167
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12748
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14200
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19833
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20499
        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:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6444
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1172
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

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

  private boolean jj_2_3(int xla) {
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 222
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2776
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3711
                  jjCheckNAddStates(0, 2);
                  if (curChar == 92)
                     jjAddStates(14, 15);
                  break;
               case 0:
                  if (curChar == 123)
                     jjCheckNAddStates(3, 6);
                  break;
               case 1:
                  if ((0xdfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(3, 6);
                  break;
               case 3:
                  jjAddStates(16, 17);
                  break;
               case 6:
                  jjAddStates(18, 19);
                  break;
               case 8:
                  if (curChar == 125 && kind > 70)
                     kind = 70;
                  break;
               case 10:
                  if (curChar == 123)
                     jjCheckNAddStates(7, 10);
                  break;
               case 11:
                  if ((0xdfffffffffffffffL & l) != 0L)
                     jjCheckNAddStates(7, 10);
                  break;
               case 13:
                  jjAddStates(20, 21);
                  break;
               case 16:
                  jjAddStates(22, 23);
                  break;
               case 18:
                  if (curChar == 125 && kind > 71)
                     kind = 71;
                  break;
               case 21:
               case 23:
                  jjCheckNAddStates(11, 13);
                  break;
               case 28:
                  if (kind > 79)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1439
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30526
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31169
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31470
      case COMPOUND:
      case CALL:
      case DDL:
      case DISASSOCIATE:
      case EACH:
      case FOLLOWS:
      case LOGOFF:
      case LOGON:
      case NESTED:
      case NOAUDIT:
      case SCHEMA:
      case SERVERERROR:
      case SHUTDOWN:
      case STARTUP:
      case STATEMENT:
      case STATISTICS:
      case SUSPEND:
      case TRUNCATE:
      case WRAPPED:
      case LIBRARY:
      case NAME:
      case STRUCT:
      case CONTEXT:
      case PARAMETERS:
      case LENGTH:
      case TDO:
      case MAXLEN:
      case CHARSETID:
      case CHARSETFORM:
      case ACCEPT:
      case ACCESSIBLE:
      case COPY:
      case DEFINE:
      case DISCONNECT:
      case HOST:
      case PRINT:
      case QUIT:
      case REMARK:
      case UNDEFINE:
      case VARIABLE:
      case WHENEVER:
      case ATTACH:
      case CAST:
      case TREAT:
      case TRIM:
      case LEFT:
      case RIGHT:
      case BOTH:
      case EMPTY:
      case MULTISET:
      case SUBMULTISET:
      case LEADING:
      case TRAILING:
      case CHAR_CS:
      case NCHAR_CS:
      case DBTIMEZONE:
      case SESSIONTIMEZONE:
      case AUTHENTICATED:
      case LINK:
      case SHARED:
      case DIRECTORY:
      case USER:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1619
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4430
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5522
      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);
   }
  }
}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 730
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1959
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2813
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5862
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7140
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7587
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8609
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9602
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9902
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10561
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11163
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11463
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12419
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13409
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14866
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15148
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15428
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17454
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18698
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18982
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19223
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19534
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19896
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22627
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23544
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23900
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24855
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25646
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26008
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26619
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27861
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28275
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31164
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31465
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/symboltable/ScopeAndDeclarationFinder.java 278
net/sourceforge/pmd/lang/plsql/symboltable/ScopeAndDeclarationFinder.java 316
public Object visit(ASTTypeMethod node, Object data) {
	createMethodScope(node);
	ASTMethodDeclarator md = node.getFirstChildOfType(ASTMethodDeclarator.class);
	// A PLSQL Method (FUNCTION|PROCEDURE) may be schema-level 
	try
	{
	  node.getScope().getEnclosingScope(ClassScope.class).addDeclaration(new MethodNameDeclaration(md));
	}
	catch (Exception e)
	{
	  //@TODO possibly add to a pseudo-ClassScope equivalent to the Schema name 
	  LOGGER.finest("ProgramUnit getEnclosingClassScope Exception string=\""+e.getMessage()+"\"");
	  if("getEnclosingClassScope() called on SourceFileScope".equals(e.getMessage()))
	  {
            LOGGER.finest("ClassScope skipped for Schema-level method: methodName=" 
		               + node.getMethodName()
		               + "; Image=" + node.getImage()
		              );
	   
	    //A File-level/Schema-level object may have a Schema-name explicitly specified in the declaration 
	    ASTObjectNameDeclaration on = md.getFirstChildOfType(ASTObjectNameDeclaration.class);
	    if( 1 < on.jjtGetNumChildren())
	    {
              ASTID schemaName = on.getFirstChildOfType(ASTID.class);
	      LOGGER.finest("SchemaName for Schema-level method: methodName=" 
				 + node.getMethodName()
				 + "; Image=" + node.getImage()
				 + "is " + schemaName.getImage()
				);
	     
	    }
	  }
	}
	cont(node);
	return data;
  }

    @Override
    public Object visit(ASTProgramUnit node, Object data) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4230
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7774
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16798
        simpleNode = Datatype();
                                      sb.append(" "); sb.append(simpleNode.getImage());
      }
      jj_consume_token(CC_END);
                    sb.append(" "); sb.append(token.image);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10641
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1639
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39794
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3627
    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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15867
      case REF:
      case RELEASE:
      case RELIES_ON:
      case RENAME:
      case RESULT:
      case RETURN:
      case RETURNING:
      case REVERSE:
      case ROLLBACK:
      case ROW:
      case ROWS:
      case ROWID:
      case ROWNUM:
      case SAVE:
      case SAVEPOINT:
      case SECOND:
      case SELF:
      case SET:
      case SMALLINT:
      case SPACE:
      case SQL:
      case SQLCODE:
      case SQLERRM:
      case STATIC:
      case SUBTYPE:
      case SUBSTITUTABLE:
      case SUCCESSFUL:
      case SYSDATE:
      case SYS_REFCURSOR:
      case TEMPORARY:
      case TIME:
      case TIMESTAMP:
      case TIMEZONE_REGION:
      case TIMEZONE_ABBR:
      case TIMEZONE_MINUTE:
      case TIMEZONE_HOUR:
      case TRANSACTION:
      case TRUE:
      case TYPE:
      case UNDER:
      case USING:
      case YES:
      case SHOW:
      case A:
      case VARCHAR:
      case VARCHAR2:
      case DOUBLE:
      case DEC:
      case PRECISION:
      case INT:
      case NUMERIC:
      case SIGNTYPE:
      case NCHAR:
      case NVARCHAR2:
      case STRING:
      case UROWID:
      case VARRAY:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java 42
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java 64
    public void compute(ASTConstructorDeclaration node) {
	this.computeNow(node);
    }

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

	List<VariableAccess> undefinitions = markUsages(inode);

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

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

    private List<VariableAccess> markUsages(DataFlowNode inode) {
	// undefinitions was once a field... seems like it works fine as a local
	List<VariableAccess> undefinitions = new ArrayList<VariableAccess>();
	Set<Map<NameDeclaration, List<NameOccurrence>>> variableDeclarations = collectDeclarations(inode);
	for (Map<NameDeclaration, List<NameOccurrence>> declarations : variableDeclarations) {
	    for (Map.Entry<NameDeclaration, List<NameOccurrence>> entry : declarations.entrySet()) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1714
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2565
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2914
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3284
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 3633
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4002
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4351
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4897
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23655
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24260
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 24610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25401
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25763
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28417
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28890
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19901
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29139
          case DATABASE:
          case CALL:
          case DDL:
          case DISASSOCIATE:
          case EACH:
          case FOLLOWS:
          case LOGOFF:
          case LOGON:
          case NESTED:
          case NOAUDIT:
          case SCHEMA:
          case SERVERERROR:
          case SHUTDOWN:
          case STARTUP:
          case STATEMENT:
          case STATISTICS:
          case SUSPEND:
          case TRUNCATE:
          case WRAPPED:
          case LIBRARY:
          case NAME:
          case STRUCT:
          case CONTEXT:
          case PARAMETERS:
          case LENGTH:
          case TDO:
          case MAXLEN:
          case CHARSETID:
          case CHARSETFORM:
          case ACCEPT:
          case ACCESSIBLE:
          case COPY:
          case DEFINE:
          case DISCONNECT:
          case HOST:
          case PRINT:
          case QUIT:
          case REMARK:
          case UNDEFINE:
          case VARIABLE:
          case WHENEVER:
          case ATTACH:
          case CAST:
          case TREAT:
          case TRIM:
          case LEFT:
          case RIGHT:
          case BOTH:
          case EMPTY:
          case MULTISET:
          case SUBMULTISET:
          case LEADING:
          case TRAILING:
          case CHAR_CS:
          case NCHAR_CS:
          case AUTHENTICATED:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/ast/JavaCharStream.java 530
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 386
    ReInit(dstream, 1, 1, 4096);
  }

  /** @return token image as String */
  public String GetImage()
  {
    if (bufpos >= tokenBegin)
      return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
    else
      return new String(buffer, tokenBegin, bufsize - tokenBegin) +
                              new String(buffer, 0, bufpos + 1);
  }

  /** @return suffix */
  public char[] GetSuffix(int len)
  {
    char[] ret = new char[len];

    if ((bufpos + 1) >= len)
      System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
    else
    {
      System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
                                                        len - bufpos - 1);
      System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
    }

    return ret;
  }

  /** Set buffers back to null when finished. */
  public void Done()
  {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19727
        Expression();
        break;
      case 5:
      case 16:
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDEXTYPE:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12645
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12975
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16476
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16875
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20395
      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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };

/** Lexer state names. */
public static final String[] lexStateNames = {
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2390
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3810
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 4444
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 4898
                  break;
               case 2:
                  if ((0x10000000100000L & l) != 0L)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 5:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 6:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 5;
                  break;
               case 7:
                  if (curChar == 125)
                     jjCheckNAddTwoStates(3, 4);
                  break;
               case 8:
                  if ((0x10000000100000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 7;
                  break;
               case 9:
                  if ((0x2000000020L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 8;
                  break;
               case 10:
                  if ((0x8000000080000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 9;
                  break;
               case 11:
                  if (curChar == 123)
                     jjstateSet[jjnewStateCnt++] = 10;
                  break;
               case 12:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2428
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3481
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7349
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12553
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12588
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26298
 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
    try {
      simpleNode = ID();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1494
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4298
   if (lexState >= 5 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

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

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

   return t;
}

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

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

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

/**
 * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
 */
  final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17291
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18535
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19061
      case 17:
      case REPLACE:
      case DEFINER:
      case CURRENT_USER:
      case LANGUAGE:
      case INLINE:
      case ADD:
      case AGGREGATE:
      case ARRAY:
      case AT:
      case ATTRIBUTE:
      case AUTHID:
      case BODY:
      case BULK:
      case BYTE:
      case CASCADE:
      case CASE:
      case CLOSE:
      case COALESCE:
      case COLLECT:
      case COLUMN:
      case COMMENT:
      case COMMIT:
      case CONSTRUCTOR:
      case CONTINUE:
      case CONVERT:
      case CURRENT:
      case CURSOR:
      case DATA:
      case DATE:
      case DAY:
      case DISABLE:
      case EDITIONABLE:
      case ELEMENT:
      case ENABLE:
      case ESCAPE:
      case EXCEPT:
      case EXCEPTIONS:
      case EXIT:
      case EXTERNAL:
      case EXTENDS:
      case EXTRACT:
      case FALSE:
      case FINAL:
      case FORCE:
      case FUNCTION:
      case GLOBAL:
      case HASH:
      case HEAP:
      case HOUR:
      case IMMEDIATE:
      case INDEXTYPE:
File Line
net/sourceforge/pmd/lang/java/symboltable/TypeSet.java 158
net/sourceforge/pmd/lang/plsql/symboltable/TypeSet.java 75
                        return pmdClassLoader.loadClass(importPkg + '.' + name);
                    } catch (ClassNotFoundException cnfe) {
                    }
                }
            }
            throw new ClassNotFoundException("Type " + name + " not found");
        }
    }

    /**
     * Resolver that resolves primitive types such as int or double.
     */
    public static class PrimitiveTypeResolver implements Resolver {
        private Map<String, Class<?>> primitiveTypes = new HashMap<String, Class<?>>();
        /**
         * Creates a new {@link PrimitiveTypeResolver}.
         */
        @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);
        }
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4177
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4179
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4180
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4182
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4183
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4184
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4185
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4187
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4188
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4189
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4191
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4194
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4197
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1302
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6835
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22167
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22723
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27605
        jj_la1[19] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

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

  final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17715
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18128
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20309
        simpleNode = ConditionalAndExpression();
                                                sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

	public boolean equals(Object obj) {
		if (obj instanceof ConstructorNode) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/Token.java 9
net/sourceforge/pmd/lang/jsp/ast/Token.java 9
net/sourceforge/pmd/lang/plsql/ast/Token.java 27
net/sourceforge/pmd/lang/vm/ast/Token.java 9
public class Token implements java.io.Serializable {

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

  /**
   * An integer that describes the kind of this token.  This numbering
   * system is determined by JavaCCParser, and a table of these numbers is
   * stored in the file ...Constants.java.
   */
  public int kind;

  /** The line number of the first character of this Token. */
  public int beginLine;
  /** The column number of the first character of this Token. */
  public int beginColumn;
  /** The line number of the last character of this Token. */
  public int endLine;
  /** The column number of the last character of this Token. */
  public int endColumn;

  /**
   * The string image of the token.
   */
  public String image;

  /**
   * A reference to the next regular (non-special) token from the input
   * stream.  If this is the last token from the input stream, or if the
   * token manager has not read tokens beyond this one, this field is
   * set to null.  This is true only if this token is also a regular
   * token.  Otherwise, see below for a description of the contents of
   * this field.
   */
  public Token next;

  /**
   * This field is used to access special tokens that occur prior to this
   * token, but after the immediately preceding regular (non-special) token.
   * If there are no such special tokens, this field is set to null.
   * When there are more than one such special token, this field refers
   * to the last of these special tokens, which in turn refers to the next
   * previous special token through its specialToken field, and so on
   * until the first special token (whose specialToken field is null).
   * The next fields of special tokens refer to other special tokens that
   * immediately follow it (without an intervening regular token).  If there
   * is no such token, this field is null.
   */
  public Token specialToken;

  /**
   * An optional attribute value of the Token.
   * Tokens which are not used as syntactic sugar will often contain
   * meaningful values that will be used later on by the compiler or
   * interpreter. This attribute value is often different from the image.
   * Any subclass of Token that actually wants to return a non-null value can
   * override this method as appropriate.
   */
  public Object getValue() {
    return null;
  }

  /**
   * No-argument constructor
   */
  public Token() {}

  /**
   * Constructs a new token for the specified Image.
   */
  public Token(int kind)
  {
    this(kind, null);
  }

  /**
   * Constructs a new token for the specified Image and Kind.
   */
  public Token(int kind, String image)
  {
    this.kind = kind;
    this.image = image;
  }

  /**
   * Returns the image.
   */
  public String toString()
  {
    return image;
  }

  /**
   * Returns a new Token object, by default. However, if you want, you
   * can create and return subclass objects based on the value of ofKind.
   * Simply add the cases to the switch for all those special cases.
   * For example, if you have a subclass of Token called IDToken that
   * you want to create if ofKind is ID, simply add something like :
   *
   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
   *
   * to the following switch statement. Then you can cast matchedToken
   * variable to the appropriate type and use sit in your lexical actions.
   */
  public static Token newToken(int ofKind, String image)
  {
    switch(ofKind)
    {
      default : return new Token(ofKind, image);
    }
  }

  public static Token newToken(int ofKind)
  {
    return newToken(ofKind, null);
  }

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

  final public ASTExitStatement ExitStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17667
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17715
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17782
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18128
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18199
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20309
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20359
                                    sb.append("."); sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTTrimExpression TrimExpression() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/ast/JavaCharStream.java 214
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 140
  }

  protected void UpdateLineColumn(char c)
  {
    column++;

    if (prevCharIsLF)
    {
      prevCharIsLF = false;
      line += (column = 1);
    }
    else if (prevCharIsCR)
    {
      prevCharIsCR = false;
      if (c == '\n')
      {
        prevCharIsLF = true;
      }
      else
        line += (column = 1);
    }

    switch (c)
    {
      case '\r' :
        prevCharIsCR = true;
        break;
      case '\n' :
        prevCharIsLF = true;
        break;
      case '\t' :
        column--;
        column += (tabSize - (column % tabSize));
        break;
      default :
        break;
    }

    bufline[bufpos] = line;
    bufcolumn[bufpos] = column;
  }

/** Read a character. */
  public char readChar() throws java.io.IOException
  {
    if (inBuf > 0)
    {
      --inBuf;

      if (++bufpos == bufsize)
        bufpos = 0;

      return buffer[bufpos];
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7234
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17537
      jj_consume_token(7);
       sb.append(")");
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1658
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1869
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2074
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2703
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3456
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5173
                     jjAddStates(98, 99);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 98 - (jjnewStateCnt = startsAt)))
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/TokenMgrError.java 44
net/sourceforge/pmd/lang/ast/TokenMgrError.java 51
net/sourceforge/pmd/lang/java/ast/ParseException.java 142
net/sourceforge/pmd/lang/jsp/ast/ParseException.java 142
net/sourceforge/pmd/lang/plsql/ast/ParseException.java 160
net/sourceforge/pmd/lang/vm/ast/ParseException.java 142
        final StringBuffer retval = new StringBuffer();
        char ch;
        for (int i = 0; i < str.length(); i++) {
            switch (str.charAt(i)) {
                case 0:
                    continue;
                case '\b':
                    retval.append("\\b");
                    continue;
                case '\t':
                    retval.append("\\t");
                    continue;
                case '\n':
                    retval.append("\\n");
                    continue;
                case '\f':
                    retval.append("\\f");
                    continue;
                case '\r':
                    retval.append("\\r");
                    continue;
                case '\"':
                    retval.append("\\\"");
                    continue;
                case '\'':
                    retval.append("\\\'");
                    continue;
                case '\\':
                    retval.append("\\\\");
                    continue;
                default:
                    if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16390
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16422
  ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      CursorUnit();
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTCursorBody CursorBody() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7442
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13264
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13810
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19389
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22240
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22482
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31332
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7457
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13825
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18849
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19404
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21294
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22497
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9678
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16285
          jj_la1[120] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTStatement Statement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6312
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6752
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9977
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15516
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26752
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29385
        jj_la1[69] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

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

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

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

  final public ASTCursorSpecification CursorSpecification() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/java/symboltable/MethodNameDeclaration.java 49
net/sourceforge/pmd/lang/plsql/symboltable/MethodNameDeclaration.java 67
            sb.append(',');
        }
        if (sb.charAt(sb.length() - 1) == ',') {
            sb.deleteCharAt(sb.length() - 1);
        }
        sb.append(')');
        return sb.toString();
    }

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

        MethodNameDeclaration other = (MethodNameDeclaration) o;

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

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

        // compare parameter types
        ASTFormalParameters myParams = (ASTFormalParameters) node.jjtGetChild(0);
File Line
net/sourceforge/pmd/lang/ast/JavaCharStream.java 491
net/sourceforge/pmd/lang/ast/SimpleCharStream.java 346
  public JavaCharStream(java.io.InputStream dstream)
  {
    this(dstream, 1, 1, 4096);
  }

/** Reinitialise. */
  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
  {
    ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
  }

/** Reinitialise. */
  public void ReInit(java.io.InputStream dstream, int startline,
  int startcolumn, int buffersize)
  {
    ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
  }
/** Reinitialise. */
  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7700
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19657
          }
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

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

  final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18776
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19987
        Expression();
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

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

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

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

  final public void ExplicitConstructorInvocation() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 654
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5786
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8533
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8807
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9826
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10157
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10485
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10785
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11087
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11387
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11719
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12343
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12738
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13069
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14190
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14790
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15072
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15352
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16570
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17382
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18345
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18626
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18910
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19151
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19823
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20489
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23468
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27785
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12557
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26302
      simpleNode = ID();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

  final public ASTCompilationDataType CompilationDataType() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17228
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17620
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17668
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17716
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17783
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18129
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18200
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18776
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19987
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20310
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20359
                                    sb.append("."); sb.append(simpleNode.getImage());
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTTrimExpression TrimExpression() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10745
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1748
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39928
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3736
    for (int i = 0; i < 128; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    jj_endpos = 0;
    jj_rescan_token();
    jj_add_error_token(0, 0);
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

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

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

  private void jj_rescan_token() {
    jj_rescan = true;
    for (int i = 0; i < 75; i++) {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 302
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7385
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12557
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12592
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21573
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26302
      SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 423
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7235
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7778
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16840
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17152
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17538
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27969
      Skip2NextTokenOccurrence(EOL);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

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

  final public ASTBlock Block() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2044
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6702
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6838
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22113
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22170
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22726
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25078
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26209
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27608
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (true) throw (ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPackageBody PackageBody() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7321
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7702
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7867
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16726
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17229
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17621
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17669
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17717
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17784
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18016
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18130
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18201
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18496
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18777
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19319
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19659
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19988
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20311
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20360
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36091
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_351() {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1627
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2242
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 4181
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4438
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5530
        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);
   }
  }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 303
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1306
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6839
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7386
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10029
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12558
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12593
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20252
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21574
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22114
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22171
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22727
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26210
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26271
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26303
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27609
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 424
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7236
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7703
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7779
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7868
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16727
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16803
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17153
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17230
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17622
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17670
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17718
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17785
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18017
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18131
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18202
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18497
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18778
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19320
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19660
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19989
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20312
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20361
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27971
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

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

  final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36014
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38819
    if (jj_scan_token(43)) return true;
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java 11
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java 92
	}

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

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

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

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

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

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

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

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

   return t;
}

int curLexState = 0;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7457
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13006
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13279
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13825
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14127
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16906
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17320
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18282
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18564
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19404
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19760
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21294
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22497
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7537
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9551
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10178
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12759
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13359
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13632
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13905
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14211
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16591
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16990
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17403
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18366
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18647
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18931
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19172
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19484
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19844
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20510
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22335
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22577
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10727
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39880
    for (int i = 0; i < 151; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
          if ((jj_la1_3[i] & (1<<j)) != 0) {
            la1tokens[96+j] = true;
          }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14604
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28738
        jj_la1[170] = jj_gen;
        ;
      }
      jj_consume_token(4);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTPipelineStatement PipelineStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4869
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1686
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void IfStatement() throws ParseException {
 /*@bgen(jjtree) IfStatement */
  ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(IF);
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36016
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36017
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36018
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36020
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36022
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36023
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36024
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36025
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36026
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36027
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36028
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36029
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36030
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36033
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36034
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36035
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36036
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36037
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36038
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36039
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36040
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36042
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36043
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36044
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36045
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36046
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36048
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36050
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36052
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36053
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36054
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36055
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36056
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36058
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36060
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36061
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36062
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36063
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36064
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36066
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36067
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36068
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36069
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36070
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36071
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36072
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36073
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36074
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36075
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36076
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36077
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36078
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36079
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36080
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36083
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36084
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36086
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36087
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36088
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36089
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36090
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4199
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2505
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Expression syntax follows.
 */
  final public void Expression() throws ParseException {
 /*@bgen(jjtree) Expression */
  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2209
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4405
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5497
       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;
        }
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 54
net/sourceforge/pmd/lang/vm/ast/VmParser.java 253
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
  }

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

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

  final public ASTArgumentList ArgumentList() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38821
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36092
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 824
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8964
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10335
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11549
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11881
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12193
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14369
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14435
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21890
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21949
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23988
        jj_la1[9] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
    throw new Error("Missing return statement in function");
  }

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

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

  final public ASTArgumentList ArgumentList() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38822
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36093
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/java/symboltable/TypeSet.java 234
net/sourceforge/pmd/lang/plsql/symboltable/TypeSet.java 130
    public String getASTCompilationUnitPackage() {
        return pkg;
    }

    /**
     * Adds a import to the list of imports
     * @param importString the import to add
     */
    public void addImport(String importString) {
        imports.add(importString);
    }

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

    /**
     * Resolves a class by its name using all known resolvers.
     * @param name the name of the class, can be a simple name or a fully qualified name.
     * @return the class
     * @throws ClassNotFoundException if there is no such class
     */
    public Class<?> findClass(String name) throws ClassNotFoundException {
        // we don't build the resolvers until now since we first want to get all
        // the imports
        if (resolvers.isEmpty()) {
            buildResolvers();
        }

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

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

    private void buildResolvers() {
        resolvers.add(new PrimitiveTypeResolver());
        resolvers.add(new VoidResolver());
        resolvers.add(new ExplicitImportResolver(pmdClassLoader, imports));
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2505
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6754
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9979
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15518
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20684
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26754
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29218
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29387
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTBlock Block() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38823
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36094
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/AbstractJavaNode.java 19
net/sourceforge/pmd/lang/jsp/ast/AbstractJspNode.java 16
    public AbstractJavaNode(JavaParser parser, int id) {
        super(id);
        this.parser = parser;
    }

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

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

    /**
     * Accept the visitor. *
     */
    public Object jjtAccept(JavaParserVisitor visitor, Object data) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9681
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10638
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10938
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11240
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16288
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
    throw new Error("Missing return statement in function");
  }

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

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

  final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38824
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 269
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12908
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28741
      jj_consume_token(0);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 500
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 826
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2123
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2506
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6755
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8966
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9980
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10337
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10639
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10939
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11241
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11551
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11883
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12195
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14371
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14437
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15519
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16289
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21892
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21951
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22845
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23990
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26755
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29219
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29388
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

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

  final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38825
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36096
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10772
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39955
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3763
    for (int i = 0; i < 75; 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;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 270
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 827
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2124
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6316
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6355
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8967
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9251
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9683
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10338
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12909
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14438
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14608
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15520
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16395
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16427
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20792
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21502
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22759
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22846
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29389
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38826
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36097
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38827
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36098
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/ecmascript/rule/EcmascriptRuleChainVisitor.java 18
net/sourceforge/pmd/lang/xml/rule/XmlRuleChainVisitor.java 16
public class EcmascriptRuleChainVisitor extends AbstractRuleChainVisitor {

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

    protected void visit(Rule rule, Node node, RuleContext ctx) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 424
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 879
      }
                  jjtree.closeNodeScope(jjtn000, true);
                  jjtc000 = false;
                 jjtn000.setImage(content.toString());
    } catch (Throwable jjte000) {
            if (jjtc000) {
              jjtree.clearNodeScope(jjtn000);
              jjtc000 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte000;}
            }
            if (jjte000 instanceof ParseException) {
              {if (true) throw (ParseException)jjte000;}
            }
            {if (true) throw (Error)jjte000;}
    } finally {
            if (jjtc000) {
              jjtree.closeNodeScope(jjtn000, true);
            }
    }
  }

  final public String UnparsedText() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 268
net/sourceforge/pmd/lang/vm/ast/VmParser.java 252
      }
      jj_consume_token(0);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38828
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36099
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 54
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 269
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 4212
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5913
                                               input_stream.backup(1);
         break;
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

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

}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38829
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36100
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2325
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 4213
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5914
         break;
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

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

}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38830
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36101
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2326
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 4214
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4468
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5915
      default :
         break;
   }
}
private void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}

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

}
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20757
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTExitStatement ExitStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38831
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36102
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5876
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5943
      jj_consume_token(RPAREN);
                                               jjtree.closeNodeScope(jjtn000, true);
                                               jjtc000 = false;
                                              checkForBadAnnotationUsage();
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void MarkerAnnotation() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10853
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1783
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 40044
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3781
            case 74: jj_3_75(); break;
          }
        }
        p = p.next;
      } while (p != null);
      } catch(LookaheadSuccess ls) { }
    }
    jj_rescan = false;
  }

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

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

}
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 54
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6354
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9250
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12521
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12908
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14607
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14641
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16394
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20791
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21539
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21799
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28741
net/sourceforge/pmd/lang/vm/ast/VmParser.java 253
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

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

/**
 * All global definitions of triggers, functions and procedures are evaluated here.
 * Every occurence goes under a new PACKAGE-Node in the XML document.
 * This happens, cause a global "block" does not have a definied start and end token 
 * like a package specification or a package body.
 * Thats why every construct is handled like a new part of the global package.
 * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
 * and slow down the whole parsing.
 * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
 * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
 * choose the correct way on a given base. So we can't negate it easily.
 * On the other hand I could also hold the global state in a global variable. 
 * But this does not seems the correct way to solve the problem, I think.
 *
 * 2006-05-17 - Matthias Hendler - added
 */
  final public ASTGlobal Global() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38832
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36103
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3712
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 4813
                  break;
               case 0:
                  if ((0x100000200L & l) != 0L)
                     jjCheckNAddTwoStates(0, 1);
                  break;
               case 1:
                  if (curChar == 35)
                     jjCheckNAddTwoStates(6, 11);
                  break;
               case 3:
                  if (curChar == 32)
                     jjAddStates(115, 116);
                  break;
               case 4:
                  if (curChar == 40 && kind > 15)
                     kind = 15;
                  break;
               case 13:
                  if ((0x3ff200000000000L & l) == 0L)
                     break;
                  if (kind > 68)
                     kind = 68;
                  jjstateSet[jjnewStateCnt++] = 13;
                  break;
               case 14:
                  if (curChar == 46)
                     jjstateSet[jjnewStateCnt++] = 15;
                  break;
               case 16:
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 55
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 501
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 827
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2124
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2507
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6316
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8967
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9683
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9981
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10338
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10640
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10940
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11242
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11552
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11884
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12196
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14372
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14438
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15520
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16290
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20686
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21687
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21893
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21952
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22846
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26756
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29220
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29389
net/sourceforge/pmd/lang/vm/ast/VmParser.java 254
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38833
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36104
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1650
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2328
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 4216
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4470
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5917
  }
}

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

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

}
File Line
net/sourceforge/pmd/lang/cpp/ast/Token.java 9
net/sourceforge/pmd/lang/java/ast/Token.java 9
net/sourceforge/pmd/lang/jsp/ast/Token.java 9
net/sourceforge/pmd/lang/plsql/ast/Token.java 27
net/sourceforge/pmd/lang/vm/ast/Token.java 9
public class Token implements java.io.Serializable {

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

  /**
   * An integer that describes the kind of this token.  This numbering
   * system is determined by JavaCCParser, and a table of these numbers is
   * stored in the file ...Constants.java.
   */
  public int kind;

  /** The line number of the first character of this Token. */
  public int beginLine;
  /** The column number of the first character of this Token. */
  public int beginColumn;
  /** The line number of the last character of this Token. */
  public int endLine;
  /** The column number of the last character of this Token. */
  public int endColumn;

  /**
   * The string image of the token.
   */
  public String image;

  /**
   * A reference to the next regular (non-special) token from the input
   * stream.  If this is the last token from the input stream, or if the
   * token manager has not read tokens beyond this one, this field is
   * set to null.  This is true only if this token is also a regular
   * token.  Otherwise, see below for a description of the contents of
   * this field.
   */
  public Token next;

  /**
   * This field is used to access special tokens that occur prior to this
   * token, but after the immediately preceding regular (non-special) token.
   * If there are no such special tokens, this field is set to null.
   * When there are more than one such special token, this field refers
   * to the last of these special tokens, which in turn refers to the next
   * previous special token through its specialToken field, and so on
   * until the first special token (whose specialToken field is null).
   * The next fields of special tokens refer to other special tokens that
   * immediately follow it (without an intervening regular token).  If there
   * is no such token, this field is null.
   */
  public Token specialToken;

  /**
   * An optional attribute value of the Token.
   * Tokens which are not used as syntactic sugar will often contain
   * meaningful values that will be used later on by the compiler or
   * interpreter. This attribute value is often different from the image.
   * Any subclass of Token that actually wants to return a non-null value can
   * override this method as appropriate.
   */
  public Object getValue() {
    return null;
  }

  /**
   * No-argument constructor
   */
  public Token() {}

  /**
   * Constructs a new token for the specified Image.
   */
  public Token(int kind)
  {
    this(kind, null);
  }

  /**
   * Constructs a new token for the specified Image and Kind.
   */
  public Token(int kind, String image)
  {
    this.kind = kind;
    this.image = image;
  }

  /**
   * Returns the image.
   */
  public String toString()
  {
    return image;
  }

  /**
   * Returns a new Token object, by default. However, if you want, you
   * can create and return subclass objects based on the value of ofKind.
   * Simply add the cases to the switch for all those special cases.
   * For example, if you have a subclass of Token called IDToken that
   * you want to create if ofKind is ID, simply add something like :
   *
   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
   *
   * to the following switch statement. Then you can cast matchedToken
   * variable to the appropriate type and use sit in your lexical actions.
   */
  public static Token newToken(int ofKind, String image)
  {
    switch(ofKind)
    {
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1733
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3721
    for (int i = 0; i < 33; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 85; i++) {
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2358
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2440
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3493
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 21 - (jjnewStateCnt = startsAt)))
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38834
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36105
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1227
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1884
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1971
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2151
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3988
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4289
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4366
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4474
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5211
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5833
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 190
          jj_la1[37] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

  final public void MarkerAnnotation() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20757
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTExitStatement ExitStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38835
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36106
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/dfa/VariableAccessVisitor.java 79
net/sourceforge/pmd/lang/plsql/dfa/VariableAccessVisitor.java 105
		    addAccess((JavaNameOccurrence)occurrence, inode);
		}
	    }
	}
	return undefinitions;
    }

    private Set<Map<NameDeclaration, List<NameOccurrence>>> collectDeclarations(DataFlowNode inode) {
	Set<Map<NameDeclaration, List<NameOccurrence>>> decls = new HashSet<Map<NameDeclaration, List<NameOccurrence>>>();
	Map<NameDeclaration, List<NameOccurrence>> varDecls;
	for (int i = 0; i < inode.getFlow().size(); i++) {
	    DataFlowNode n = inode.getFlow().get(i);
	    if (n instanceof StartOrEndDataFlowNode) {
		continue;
	    }
	    varDecls = ((JavaNode)n.getNode()).getScope().getDeclarations();
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 238
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 57
net/sourceforge/pmd/lang/vm/ast/VmParser.java 256
net/sourceforge/pmd/lang/vm/ast/VmParser.java 902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
  }

  final public void PackageDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 478
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4060
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4865
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6084
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6367
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 679
net/sourceforge/pmd/lang/vm/ast/VmParser.java 974
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38836
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36107
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31742
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ASTDDLCommand DDLCommand() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38837
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36108
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserVisitorAdapter.java 585
net/sourceforge/pmd/lang/plsql/rule/AbstractPLSQLRule.java 666
		return visit((PLSQLNode) node, data);
	}

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

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

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

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

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

        try
        {
            if (wrapAround)
            {
                System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
                System.arraycopy(buffer, 0, newbuffer,
                        bufsize - tokenBegin, bufpos);
                buffer = newbuffer;

                System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
                System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
                bufline = newbufline;

                System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
                System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
                bufcolumn = newbufcolumn;
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1228
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1885
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1972
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2152
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3922
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3989
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4290
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4367
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4475
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5212
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5834
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 191
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

  final public void ConditionalOrExpression() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38838
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36109
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/java/dfa/StatementAndBraceFinder.java 57
net/sourceforge/pmd/lang/plsql/dfa/StatementAndBraceFinder.java 80
            throw new RuntimeException("Can't build a data flow for anything other than a method or a constructor");
        }

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

        node.jjtAccept(this, dataFlow);

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

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

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

    public String toString() {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 478
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4060
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4865
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6084
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6367
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 679
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1168
net/sourceforge/pmd/lang/vm/ast/VmParser.java 974
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 479
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1408
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1549
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2041
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2223
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2290
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2404
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3620
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4061
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4596
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4866
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6085
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6368
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 680
net/sourceforge/pmd/lang/vm/ast/VmParser.java 975
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1462
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3778
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3823
        VariableDeclaratorId();
        jj_consume_token(LAMBDA);
        switch (jj_nt.kind) {
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case DOUBLE:
        case FALSE:
        case FLOAT:
        case INT:
        case LONG:
        case NEW:
        case NULL:
        case SHORT:
        case SUPER:
        case THIS:
        case TRUE:
        case VOID:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case HEX_FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case IDENTIFIER:
        case LPAREN:
        case BANG:
        case TILDE:
        case INCR:
        case DECR:
        case PLUS:
        case MINUS:
          Expression();
          break;
        case LBRACE:
          Block();
          break;
        default:
          jj_la1[97] = jj_gen;
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 287
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2841
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3776
                  jjCheckNAddStates(0, 2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 9:
               case 28:
               case 30:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 79)
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 1241
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3019
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 3168
                  jjCheckNAddTwoStates(0, 1);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 3:
               case 0:
               case 2:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 45)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38839
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36110
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/symboltable/JavaNameOccurrence.java 71
net/sourceforge/pmd/lang/plsql/symboltable/PLSQLNameOccurrence.java 58
    public JavaNode getLocation() {
        return location;
    }

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


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

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

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

    this.returnType =  dbURI.getSourceCodeType();

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

    Class.forName(driverClass);
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3778
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3823
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3880
        VariableDeclaratorId();
        jj_consume_token(LAMBDA);
        switch (jj_nt.kind) {
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case DOUBLE:
        case FALSE:
        case FLOAT:
        case INT:
        case LONG:
        case NEW:
        case NULL:
        case SHORT:
        case SUPER:
        case THIS:
        case TRUE:
        case VOID:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case HEX_FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case IDENTIFIER:
        case LPAREN:
        case BANG:
        case TILDE:
        case INCR:
        case DECR:
        case PLUS:
        case MINUS:
          Expression();
          break;
        case LBRACE:
          Block();
          break;
        default:
          jj_la1[97] = jj_gen;
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 1899
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 1983
         return ((jjbitVec29[i2] & l2) != 0L);
      case 49:
         return ((jjbitVec30[i2] & l2) != 0L);
      case 77:
         return ((jjbitVec31[i2] & l2) != 0L);
      case 159:
         return ((jjbitVec32[i2] & l2) != 0L);
      case 164:
         return ((jjbitVec33[i2] & l2) != 0L);
      case 215:
         return ((jjbitVec34[i2] & l2) != 0L);
      case 250:
         return ((jjbitVec35[i2] & l2) != 0L);
      case 251:
         return ((jjbitVec36[i2] & l2) != 0L);
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38840
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36111
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/java/dfa/StatementAndBraceFinder.java 256
net/sourceforge/pmd/lang/plsql/dfa/StatementAndBraceFinder.java 579
        LOGGER.finest("pushOnStack CONTINUE_STATEMENT: line " + node.getBeginLine() +", column " + node.getBeginColumn());
        return super.visit(node, data);
    }

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

    public Object visit(ASTThrowStatement node, Object data) {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2707
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2745
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2783
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2821
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2859
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2910
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3003
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3056
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3107
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3162
        ConditionalAndExpression();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    }
    }
  }

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

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

  final public void TryStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38841
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36112
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/AbstractJavaNode.java 22
net/sourceforge/pmd/lang/jsp/ast/AbstractJspNode.java 19
net/sourceforge/pmd/lang/plsql/ast/AbstractPLSQLNode.java 23
    }

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

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

    /**
     * Accept the visitor. *
     */
    public Object jjtAccept(JavaParserVisitor visitor, Object data) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1440
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 879
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1490
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6168
        jj_la1[28] = jj_gen;
        ;
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

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

  final public void FormalParameter() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3382
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4765
            jj_la1[84] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
    } catch (Throwable jjte000) {
   if (jjtc000) {
     jjtree.clearNodeScope(jjtn000);
     jjtc000 = false;
   } else {
     jjtree.popNode();
   }
   if (jjte000 instanceof RuntimeException) {
     {if (true) throw (RuntimeException)jjte000;}
   }
   if (jjte000 instanceof ParseException) {
     {if (true) throw (ParseException)jjte000;}
   }
   {if (true) throw (Error)jjte000;}
    } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4596
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1169
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5393
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5743
        jj_la1[133] = jj_gen;
        ;
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ThrowStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20057
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20757
net/sourceforge/pmd/lang/vm/ast/VmParser.java 890
        if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38842
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36113
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1033
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1126
        jj_la1[18] = jj_gen;
        ;
      }
      jj_consume_token(RBRACKET);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

/**
 *  supports the [n..m] vector generator for use in
 *  the #foreach() to generate measured ranges w/o
 *  needing explicit support from the app/servlet
 */
  final public void IntegerRange() throws ParseException {
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2522
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2620
                          ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
          UnaryExpression();
        } catch (Throwable jjte001) {
                          if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte001;}
                          }
                          {if (true) throw (Error)jjte001;}
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  2);
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 237
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10031
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20254
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20314
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20363
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
 jjtn000.setComments(token_source.comments);
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 327
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5393
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5743
        jj_la1[6] = jj_gen;
        ;
      }
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

  final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1227
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1884
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1971
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2151
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3537
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3988
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4289
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4366
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4474
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5211
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5833
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 190
          jj_la1[37] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2670
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2708
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2746
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2784
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2822
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2860
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2911
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2945
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3004
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3057
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3108
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3163
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3541
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    }
    }
  }

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

  final public void DoStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38843
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36114
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31742
net/sourceforge/pmd/lang/vm/ast/VmParser.java 902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 280
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5425
      Name();
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 478
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1407
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1548
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2040
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2222
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2289
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2403
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3243
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3619
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4060
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4865
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6084
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6367
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 679
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1168
net/sourceforge/pmd/lang/vm/ast/VmParser.java 974
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1461
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 57
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
net/sourceforge/pmd/lang/vm/ast/VmParser.java 256
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 579
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 1350
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2538
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 60)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 664
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1532
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 5796
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8543
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8817
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9540
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9836
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10795
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11097
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12041
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12353
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14800
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15082
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15362
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23478
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27795
        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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38844
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36115
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 280
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4978
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5425
      Name();
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 881
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1130
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1492
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4824
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6170
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6269
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

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

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

  final public void FormalParameter() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 10727
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1733
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 39880
net/sourceforge/pmd/lang/vm/ast/VmParser.java 3721
    for (int i = 0; i < 151; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38845
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 852
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1663
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
      jj_consume_token(END);
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1684
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1808
      }
      jj_consume_token(END);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

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

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

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

    public int getArrayDepth() {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 281
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4979
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5396
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5426
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5746
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

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

  final public void EnumDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1019
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1309
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5513
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2054
        jj_la1[30] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

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

  final public void PreDecrementExpression() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3538
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3922
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4508
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4944
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5151
      jj_consume_token(COLON);
      Statement();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

  final public void TryStatement() throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 272
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 426
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 829
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 1308
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2047
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2126
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 2509
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 4688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6318
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6357
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 6841
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7238
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7324
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7356
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7388
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7705
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7781
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7870
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8186
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8367
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 8969
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9253
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9685
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 9983
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10642
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10942
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11244
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11554
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 11886
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12198
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12524
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12560
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12595
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12911
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12944
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13495
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13768
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14032
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14065
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14374
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14440
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14610
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14644
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 15522
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16021
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16095
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16292
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16365
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16397
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16429
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16805
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16843
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17155
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17232
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17541
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17624
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17672
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17720
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17787
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18019
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18085
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18133
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18204
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18499
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18780
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19322
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19662
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19991
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20255
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20315
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20364
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20643
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20688
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20794
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21504
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21542
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21576
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21689
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21802
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21895
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21954
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22051
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22116
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22173
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22729
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22761
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22848
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 23993
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 25081
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26212
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26273
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26305
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 26758
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27611
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 27973
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 28744
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29222
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29391
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 30984
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31285
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 31742
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 32061
        {if (true) return jjtn000 ;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
    throw new Error("Missing return statement in function");
  }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38846
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36117
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 281
net/sourceforge/pmd/lang/java/ast/JavaParser.java 330
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4979
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5426
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 480
net/sourceforge/pmd/lang/java/ast/JavaParser.java 707
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1409
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2042
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2224
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2291
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2405
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3621
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4062
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4209
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4597
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4664
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4867
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5255
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5588
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5986
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6086
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6369
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 681
net/sourceforge/pmd/lang/vm/ast/VmParser.java 976
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1463
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1229
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1886
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1973
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2153
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3923
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3990
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4291
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4368
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4476
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5213
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5835
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 192
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1892
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1988
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5458
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5676
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5705
      Block();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

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

  final public void LambdaExpression() throws ParseException {
File Line
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 579
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 1350
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 1531
net/sourceforge/pmd/lang/jsp/ast/JspParserTokenManager.java 2538
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 60)
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 7503
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 10143
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 12724
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13055
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13325
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13598
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 13871
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 14176
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16556
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 16955
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 17368
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18331
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18612
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 18896
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19137
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19450
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 19809
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 20475
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 21340
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22301
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 22543
          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:
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38847
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36118
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2158
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2198
        ConditionalAndExpression();
      } catch (Throwable jjte001) {
                     if (jjtc001) {
                       jjtree.clearNodeScope(jjtn001);
                       jjtc001 = false;
                     } else {
                       jjtree.popNode();
                     }
                     if (jjte001 instanceof RuntimeException) {
                       {if (true) throw (RuntimeException)jjte001;}
                     }
                     if (jjte001 instanceof ParseException) {
                       {if (true) throw (ParseException)jjte001;}
                     }
                     {if (true) throw (Error)jjte001;}
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  2);
                     }
      }
    }
  }

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

  @Deprecated
  /**
   * @deprecated
   * @see #getEndColumn
   */
  public int getColumn() {
    return bufcolumn[bufpos];
  }

  @Deprecated
  /**
   * @deprecated
   * @see #getEndLine
   */
  public int getLine() {
    return bufline[bufpos];
  }

/** Get end column. */
  public int getEndColumn() {
    return bufcolumn[bufpos];
  }

/** Get end line. */
  public int getEndLine() {
    return bufline[bufpos];
  }

/** @return column of token start */
  public int getBeginColumn() {
    return bufcolumn[tokenBegin];
  }

/** @return line number of token start */
  public int getBeginLine() {
    return bufline[tokenBegin];
  }

/** Retreat. */
  public void backup(int amount) {

    inBuf += amount;
    if ((bufpos -= amount) < 0)
      bufpos += bufsize;
  }

/** Constructor. */
  public JavaCharStream(java.io.Reader dstream,
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 480
net/sourceforge/pmd/lang/java/ast/JavaParser.java 707
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1409
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1595
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2042
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2224
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2291
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2405
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3621
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4062
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4209
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4597
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4664
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4867
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5255
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5588
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5986
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6086
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6369
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 681
net/sourceforge/pmd/lang/vm/ast/VmParser.java 976
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1463
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 571
net/sourceforge/pmd/lang/java/ast/JavaParser.java 755
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4509
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4945
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5152
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5284
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5458
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5644
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5676
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5705
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5879
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5911
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6018
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6205
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 713
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2089
      ClassOrInterfaceBody();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ExtendsList() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1230
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1887
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1974
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2154
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3747
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3924
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3991
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4292
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4369
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4477
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4769
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5214
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5836
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 193
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1893
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1989
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36119
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38848
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4200
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1658
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 1869
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2074
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 2703
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3224
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 3456
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5173
                     jjAddStates(98, 99);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
                     kind = 19;
                  break;
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5268
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 281
net/sourceforge/pmd/lang/java/ast/JavaParser.java 571
net/sourceforge/pmd/lang/java/ast/JavaParser.java 755
net/sourceforge/pmd/lang/java/ast/JavaParser.java 882
net/sourceforge/pmd/lang/java/ast/JavaParser.java 971
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1131
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1493
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1656
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2097
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4169
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4509
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4825
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4945
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4979
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5152
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5284
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5396
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5426
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5458
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5644
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5676
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5705
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5746
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5879
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5911
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6018
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6171
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6205
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6270
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6414
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 277
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 713
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1001
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1058
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1036
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1129
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1301
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1331
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1685
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1809
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2089
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 481
net/sourceforge/pmd/lang/java/ast/JavaParser.java 640
net/sourceforge/pmd/lang/java/ast/JavaParser.java 708
net/sourceforge/pmd/lang/java/ast/JavaParser.java 927
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1021
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1063
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1231
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1311
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1410
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1596
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1888
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1975
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2043
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2155
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2225
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2292
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2406
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2505
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2542
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3578
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3622
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3748
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3992
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4063
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4210
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4293
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4370
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4478
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4598
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4665
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4770
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4868
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5215
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5256
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5515
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5589
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5837
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5987
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6087
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6370
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 194
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 682
net/sourceforge/pmd/lang/vm/ast/VmParser.java 977
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1464
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1894
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1990
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 838
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1092
        label_14:
        while (true) {
          switch (jj_nt.kind) {
          case ABSTRACT:
          case BOOLEAN:
          case BYTE:
          case CHAR:
          case CLASS:
          case _DEFAULT:
          case DOUBLE:
          case FINAL:
          case FLOAT:
          case INT:
          case INTERFACE:
          case LONG:
          case NATIVE:
          case PRIVATE:
          case PROTECTED:
          case PUBLIC:
          case SHORT:
          case STATIC:
          case SYNCHRONIZED:
          case TRANSIENT:
          case VOID:
          case VOLATILE:
          case STRICTFP:
          case IDENTIFIER:
          case LBRACE:
          case SEMICOLON:
          case AT:
          case LT:
            ;
            break;
          default:
            jj_la1[27] = jj_gen;
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6017
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6442
      jj_consume_token(ASSIGN);
      MemberValue();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36120
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38849
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 852
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1663
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1760
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1873
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1969
          }
          Statement();
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
      }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 281
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1274
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4979
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5396
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5426
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5746
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 427
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 882
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 282
net/sourceforge/pmd/lang/java/ast/JavaParser.java 482
net/sourceforge/pmd/lang/java/ast/JavaParser.java 572
net/sourceforge/pmd/lang/java/ast/JavaParser.java 641
net/sourceforge/pmd/lang/java/ast/JavaParser.java 709
net/sourceforge/pmd/lang/java/ast/JavaParser.java 756
net/sourceforge/pmd/lang/java/ast/JavaParser.java 883
net/sourceforge/pmd/lang/java/ast/JavaParser.java 928
net/sourceforge/pmd/lang/java/ast/JavaParser.java 972
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1022
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1064
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1132
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1232
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1312
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1411
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1494
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1552
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1597
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1657
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1735
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1801
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1889
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1926
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1976
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2044
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2098
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2156
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2226
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2293
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2407
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2506
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2543
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3276
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3305
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3579
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3623
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3749
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3926
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3993
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4064
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4170
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4211
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4294
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4371
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4479
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4510
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4599
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4666
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4771
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4826
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4869
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4914
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4980
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5153
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5216
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5257
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5285
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5397
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5427
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5459
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5516
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5552
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5590
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5645
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5677
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5706
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5747
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5838
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5880
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5912
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5947
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5988
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6019
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6088
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6172
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6206
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6271
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6371
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6415
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 195
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 278
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 683
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 714
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1002
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1059
net/sourceforge/pmd/lang/vm/ast/VmParser.java 978
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1037
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1130
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1302
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1332
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1465
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1686
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1810
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1895
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1991
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2057
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2090
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 330
net/sourceforge/pmd/lang/java/ast/JavaParser.java 571
net/sourceforge/pmd/lang/java/ast/JavaParser.java 755
net/sourceforge/pmd/lang/java/ast/JavaParser.java 882
net/sourceforge/pmd/lang/java/ast/JavaParser.java 971
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1131
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1493
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1656
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2097
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4169
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4509
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4825
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4945
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5152
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5284
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5458
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5644
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5676
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5705
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5879
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5911
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6018
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6171
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6205
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6270
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6414
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 277
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 713
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1001
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1058
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1036
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1129
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1301
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1331
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1685
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1809
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2089
      jj_consume_token(SEMICOLON);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 481
net/sourceforge/pmd/lang/java/ast/JavaParser.java 640
net/sourceforge/pmd/lang/java/ast/JavaParser.java 708
net/sourceforge/pmd/lang/java/ast/JavaParser.java 927
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1021
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1063
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1231
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1311
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1410
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1596
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1888
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1975
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2043
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2155
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2225
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2292
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2406
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2505
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2542
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3578
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3622
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3748
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3992
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4063
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4210
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4293
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4370
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4478
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4598
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4665
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4770
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4868
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5215
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5256
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5515
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5589
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5837
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5987
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6087
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6370
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 194
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 682
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29433
net/sourceforge/pmd/lang/vm/ast/VmParser.java 977
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1464
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1894
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1990
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2056
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 707
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1062
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1800
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2504
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3577
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4209
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4550
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4664
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5255
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5588
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5986
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1170
        ClassOrInterfaceType();
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2142
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4330
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5361
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

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

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

   for (;;)
   {
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36121
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38850
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4175
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5244
"\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, 
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2241
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2319
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2449
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2526
          RelationalExpression();
        } catch (Throwable jjte001) {
                          if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte001;}
                          }
                          {if (true) throw (Error)jjte001;}
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  2);
                          }
        }
        break;
      case LOGICAL_NOT_EQUALS:
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2346
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2553
          AdditiveExpression();
        } catch (Throwable jjte002) {
                        if (jjtc002) {
                          jjtree.clearNodeScope(jjtn002);
                          jjtc002 = false;
                        } else {
                          jjtree.popNode();
                        }
                        if (jjte002 instanceof RuntimeException) {
                          {if (true) throw (RuntimeException)jjte002;}
                        }
                        if (jjte002 instanceof ParseException) {
                          {if (true) throw (ParseException)jjte002;}
                        }
                        {if (true) throw (Error)jjte002;}
        } finally {
                        if (jjtc002) {
                          jjtree.closeNodeScope(jjtn002,  2);
                        }
        }
        break;
      case LOGICAL_LE:
File Line
net/sourceforge/pmd/lang/java/symboltable/ClassScope.java 112
net/sourceforge/pmd/lang/plsql/symboltable/ClassScope.java 111
                (occurrence.getImage() != null && occurrence.getImage().equals(className))) {
            if (variableDeclarations.isEmpty() && methodDeclarations.isEmpty()) {
                // this could happen if you do this:
                // public class Foo {
                //  private String x = super.toString();
                // }
                return null;
            }
            // return any name declaration, since all we really want is to get the scope
            // for example, if there's a
            // public class Foo {
            //  private static final int X = 2;
            //  private int y = Foo.X;
            // }
            // we'll look up Foo just to get a handle to the class scope
            // and then we'll look up X.
            if (!variableDeclarations.isEmpty()) {
                return variableDeclarations.keySet().iterator().next();
            }
            return methodDeclarations.keySet().iterator().next();
        }

        if (occurrence.isMethodOrConstructorInvocation()) {
            for (MethodNameDeclaration mnd: methodDeclarations.keySet()) {
                if (mnd.getImage().equals(occurrence.getImage())) {
File Line
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1437
net/sourceforge/pmd/lang/cpp/ast/CppParserTokenManager.java 1441
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2046
net/sourceforge/pmd/lang/java/ast/JavaParserTokenManager.java 2049
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4217
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4231
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5269
   -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, 
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 238
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 57
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 32061
net/sourceforge/pmd/lang/vm/ast/VmParser.java 256
net/sourceforge/pmd/lang/vm/ast/VmParser.java 902
 {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new RuntimeException("Missing return statement in function");
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 282
net/sourceforge/pmd/lang/java/ast/JavaParser.java 572
net/sourceforge/pmd/lang/java/ast/JavaParser.java 756
net/sourceforge/pmd/lang/java/ast/JavaParser.java 883
net/sourceforge/pmd/lang/java/ast/JavaParser.java 972
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1132
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1494
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1657
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1735
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1926
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2098
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3276
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3305
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4170
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4510
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4826
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4980
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5153
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5285
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5397
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5427
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5459
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5552
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5645
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5677
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5706
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5747
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5880
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5912
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5947
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6019
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6172
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6206
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6271
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6415
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 278
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 714
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1002
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1059
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 29434
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1037
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1130
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1302
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1332
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1686
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1810
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2090
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ImportDeclaration() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 331
net/sourceforge/pmd/lang/java/ast/JavaParser.java 482
net/sourceforge/pmd/lang/java/ast/JavaParser.java 641
net/sourceforge/pmd/lang/java/ast/JavaParser.java 709
net/sourceforge/pmd/lang/java/ast/JavaParser.java 928
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1022
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1064
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1232
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1312
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1411
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1552
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1597
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1801
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1889
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1976
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2044
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2156
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2226
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2293
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2407
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2506
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2543
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3579
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3623
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3749
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3926
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3993
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4064
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4211
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4294
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4371
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4479
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4551
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4599
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4666
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4771
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4869
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4914
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5216
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5257
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5516
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5590
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5838
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5988
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6088
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6371
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 195
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 428
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 683
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 883
net/sourceforge/pmd/lang/vm/ast/VmParser.java 978
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1465
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1895
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1991
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2057
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Modifiers. We match all modifiers in a single rule to reduce the chances of
 * syntax errors for simple modifier mistakes. It will also enable us to give
 * better error messages.
 */
  final public int Modifiers() throws ParseException {
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 571
net/sourceforge/pmd/lang/java/ast/JavaParser.java 755
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1734
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1925
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3275
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3304
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4509
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4945
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5152
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5284
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5458
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5644
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5676
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5705
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5879
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5911
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5946
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6205
net/sourceforge/pmd/lang/java/ast/JavaParser.java 6443
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 713
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2089
      ClassOrInterfaceBody();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1229
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1886
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1973
net/sourceforge/pmd/lang/java/ast/JavaParser.java 2153
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3923
net/sourceforge/pmd/lang/java/ast/JavaParser.java 3990
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4291
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4368
net/sourceforge/pmd/lang/java/ast/JavaParser.java 4476
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5213
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5835
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 192
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 32060
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1892
net/sourceforge/pmd/lang/vm/ast/VmParser.java 1988
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 1595
net/sourceforge/pmd/lang/jsp/ast/JspParser.java 1170
        jj_consume_token(RBRACKET);
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }
File Line
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5076
net/sourceforge/pmd/lang/java/ast/JavaParser.java 5360
          jj_consume_token(SEMICOLON);
          switch (jj_nt.kind) {
          case BOOLEAN:
          case BYTE:
          case CHAR:
          case DOUBLE:
          case FALSE:
          case FLOAT:
          case INT:
          case LONG:
          case NEW:
          case NULL:
          case SHORT:
          case SUPER:
          case THIS:
          case TRUE:
          case VOID:
          case INTEGER_LITERAL:
          case FLOATING_POINT_LITERAL:
          case HEX_FLOATING_POINT_LITERAL:
          case CHARACTER_LITERAL:
          case STRING_LITERAL:
          case IDENTIFIER:
          case LPAREN:
          case BANG:
          case TILDE:
          case INCR:
          case DECR:
          case PLUS:
          case MINUS:
            Expression();
            break;
          default:
            jj_la1[126] = jj_gen;
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36015
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 36122
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38820
net/sourceforge/pmd/lang/plsql/ast/PLSQLParser.java 38851
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
File Line
net/sourceforge/pmd/lang/plsql/ast/PLSQLParserTokenManager.java 4201
net/sourceforge/pmd/lang/vm/ast/VmParserTokenManager.java 5243
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, };
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2268
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2346
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2476
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2553
          RelationalExpression();
        } catch (Throwable jjte002) {
                              if (jjtc002) {
                                jjtree.clearNodeScope(jjtn002);
                                jjtc002 = false;
                              } else {
                                jjtree.popNode();
                              }
                              if (jjte002 instanceof RuntimeException) {
                                {if (true) throw (RuntimeException)jjte002;}
                              }
                              if (jjte002 instanceof ParseException) {
                                {if (true) throw (ParseException)jjte002;}
                              }
                              {if (true) throw (Error)jjte002;}
        } finally {
                              if (jjtc002) {
                                jjtree.closeNodeScope(jjtn002,  2);
                              }
        }
        break;
File Line
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2373
net/sourceforge/pmd/lang/vm/ast/VmParser.java 2580
          AdditiveExpression();
        } catch (Throwable jjte003) {
                        if (jjtc003) {
                          jjtree.clearNodeScope(jjtn003);
                          jjtc003 = false;
                        } else {
                          jjtree.popNode();
                        }
                        if (jjte003 instanceof RuntimeException) {
                          {if (true) throw (RuntimeException)jjte003;}
                        }
                        if (jjte003 instanceof ParseException) {
                          {if (true) throw (ParseException)jjte003;}
                        }
                        {if (true) throw (Error)jjte003;}
        } finally {
                        if (jjtc003) {
                          jjtree.closeNodeScope(jjtn003,  2);
                        }
        }
        break;