jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/doclint/Messages.java

--1:000000000000
+:959103a6100f
+/*
+* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.  Oracle designates this
+* particular file as subject to the "Classpath" exception as provided
+* by Oracle in the LICENSE file that accompanied this code.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package com.sun.tools.doclint;
+import java.io.PrintWriter;
+import java.text.MessageFormat;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import javax.tools.Diagnostic;
+import com.sun.source.doctree.DocTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.doclint.Env.AccessKind;
+import com.sun.tools.javac.util.StringUtils;
+/**
+* Message reporting for DocLint.
+*
+* Options are used to filter out messages based on group and access level.
+* Support can be enabled for accumulating statistics of different kinds of
+* messages.
+*
+* <p><b>This is NOT part of any supported API.
+* If you write code that depends on this, you do so at your own
+* risk.  This code and its internal interfaces are subject to change
+* or deletion without notice.</b></p>
+*/
+public class Messages {
+/**
+* Groups used to categorize messages, so that messages in each group
+* can be enabled or disabled via options.
+*/
+public enum Group {
+ACCESSIBILITY,
+HTML,
+MISSING,
+SYNTAX,
+REFERENCE;
+String optName() { return StringUtils.toLowerCase(name()); }
+String notOptName() { return "-" + optName(); }
+static boolean accepts(String opt) {
+for (Group g: values())
+if (opt.equals(g.optName())) return true;
+return false;
+}
+};
+private final Options options;
+private final Stats stats;
+ResourceBundle bundle;
+Env env;
+Messages(Env env) {
+this.env = env;
+String name = getClass().getPackage().getName() + ".resources.doclint";
+bundle = ResourceBundle.getBundle(name, Locale.ENGLISH);
+stats = new Stats(bundle);
+options = new Options(stats);
+}
+void error(Group group, DocTree tree, String code, Object... args) {
+report(group, Diagnostic.Kind.ERROR, tree, code, args);
+}
+void warning(Group group, DocTree tree, String code, Object... args) {
+report(group, Diagnostic.Kind.WARNING, tree, code, args);
+}
+void setOptions(String opts) {
+options.setOptions(opts);
+}
+void setStatsEnabled(boolean b) {
+stats.setEnabled(b);
+}
+void reportStats(PrintWriter out) {
+stats.report(out);
+}
+protected void report(Group group, Diagnostic.Kind dkind, DocTree tree, String code, Object... args) {
+if (options.isEnabled(group, env.currAccess)) {
+String msg = (code == null) ? (String) args[0] : localize(code, args);
+env.trees.printMessage(dkind, msg, tree,
+env.currDocComment, env.currPath.getCompilationUnit());
+stats.record(group, dkind, code);
+}
+}
+protected void report(Group group, Diagnostic.Kind dkind, Tree tree, String code, Object... args) {
+if (options.isEnabled(group, env.currAccess)) {
+String msg = localize(code, args);
+env.trees.printMessage(dkind, msg, tree, env.currPath.getCompilationUnit());
+stats.record(group, dkind, code);
+}
+}
+String localize(String code, Object... args) {
+String msg = bundle.getString(code);
+if (msg == null) {
+StringBuilder sb = new StringBuilder();
+sb.append("message file broken: code=").append(code);
+if (args.length > 0) {
+sb.append(" arguments={0}");
+for (int i = 1; i < args.length; i++) {
+sb.append(", {").append(i).append("}");
+}
+}
+msg = sb.toString();
+}
+return MessageFormat.format(msg, args);
+}
+// <editor-fold defaultstate="collapsed" desc="Options">
+/**
+* Handler for (sub)options specific to message handling.
+*/
+static class Options {
+Map<String, Env.AccessKind> map = new HashMap<String, Env.AccessKind>();
+private final Stats stats;
+static boolean isValidOptions(String opts) {
+for (String opt: opts.split(",")) {
+if (!isValidOption(StringUtils.toLowerCase(opt.trim())))
+return false;
+}
+return true;
+}
+private static boolean isValidOption(String opt) {
+if (opt.equals("none") || opt.equals(Stats.OPT))
+return true;
+int begin = opt.startsWith("-") ? 1 : 0;
+int sep = opt.indexOf("/");
+String grp = opt.substring(begin, (sep != -1) ? sep : opt.length());
+return ((begin == 0 && grp.equals("all")) || Group.accepts(grp))
+&& ((sep == -1) || AccessKind.accepts(opt.substring(sep + 1)));
+}
+Options(Stats stats) {
+this.stats = stats;
+}
+/** Determine if a message group is enabled for a particular access level. */
+boolean isEnabled(Group g, Env.AccessKind access) {
+if (map.isEmpty())
+map.put("all", Env.AccessKind.PROTECTED);
+Env.AccessKind ak = map.get(g.optName());
+if (ak != null && access.compareTo(ak) >= 0)
+return true;
+ak = map.get(ALL);
+if (ak != null && access.compareTo(ak) >= 0) {
+ak = map.get(g.notOptName());
+if (ak == null || access.compareTo(ak) > 0) // note >, not >=
+return true;
+}
+return false;
+}
+void setOptions(String opts) {
+if (opts == null)
+setOption(ALL, Env.AccessKind.PRIVATE);
+else {
+for (String opt: opts.split(","))
+setOption(StringUtils.toLowerCase(opt.trim()));
+}
+}
+private void setOption(String arg) throws IllegalArgumentException {
+if (arg.equals(Stats.OPT)) {
+stats.setEnabled(true);
+return;
+}
+int sep = arg.indexOf("/");
+if (sep > 0) {
+Env.AccessKind ak = Env.AccessKind.valueOf(StringUtils.toUpperCase(arg.substring(sep + 1)));
+setOption(arg.substring(0, sep), ak);
+} else {
+setOption(arg, null);
+}
+}
+private void setOption(String opt, Env.AccessKind ak) {
+map.put(opt, (ak != null) ? ak
+: opt.startsWith("-") ? Env.AccessKind.PUBLIC : Env.AccessKind.PRIVATE);
+}
+private static final String ALL = "all";
+}
+// </editor-fold>
+// <editor-fold defaultstate="collapsed" desc="Statistics">
+/**
+* Optionally record statistics of different kinds of message.
+*/
+static class Stats {
+public static final String OPT = "stats";
+public static final String NO_CODE = "";
+final ResourceBundle bundle;
+// tables only initialized if enabled
+int[] groupCounts;
+int[] dkindCounts;
+Map<String, Integer> codeCounts;
+Stats(ResourceBundle bundle) {
+this.bundle = bundle;
+}
+void setEnabled(boolean b) {
+if (b) {
+groupCounts = new int[Messages.Group.values().length];
+dkindCounts = new int[Diagnostic.Kind.values().length];
+codeCounts = new HashMap<String, Integer>();
+} else {
+groupCounts = null;
+dkindCounts = null;
+codeCounts = null;
+}
+}
+void record(Messages.Group g, Diagnostic.Kind dkind, String code) {
+if (codeCounts == null) {
+return;
+}
+groupCounts[g.ordinal()]++;
+dkindCounts[dkind.ordinal()]++;
+if (code == null) {
+code = NO_CODE;
+}
+Integer i = codeCounts.get(code);
+codeCounts.put(code, (i == null) ? 1 : i + 1);
+}
+void report(PrintWriter out) {
+if (codeCounts == null) {
+return;
+}
+out.println("By group...");
+Table groupTable = new Table();
+for (Messages.Group g : Messages.Group.values()) {
+groupTable.put(g.optName(), groupCounts[g.ordinal()]);
+}
+groupTable.print(out);
+out.println();
+out.println("By diagnostic kind...");
+Table dkindTable = new Table();
+for (Diagnostic.Kind k : Diagnostic.Kind.values()) {
+dkindTable.put(StringUtils.toLowerCase(k.toString()), dkindCounts[k.ordinal()]);
+}
+dkindTable.print(out);
+out.println();
+out.println("By message kind...");
+Table codeTable = new Table();
+for (Map.Entry<String, Integer> e : codeCounts.entrySet()) {
+String code = e.getKey();
+String msg;
+try {
+msg = code.equals(NO_CODE) ? "OTHER" : bundle.getString(code);
+} catch (MissingResourceException ex) {
+msg = code;
+}
+codeTable.put(msg, e.getValue());
+}
+codeTable.print(out);
+}
+/**
+* A table of (int, String) sorted by decreasing int.
+*/
+private static class Table {
+private static final Comparator<Integer> DECREASING = new Comparator<Integer>() {
+public int compare(Integer o1, Integer o2) {
+return o2.compareTo(o1);
+}
+};
+private final TreeMap<Integer, Set<String>> map = new TreeMap<Integer, Set<String>>(DECREASING);
+void put(String label, int n) {
+if (n == 0) {
+return;
+}
+Set<String> labels = map.get(n);
+if (labels == null) {
+map.put(n, labels = new TreeSet<String>());
+}
+labels.add(label);
+}
+void print(PrintWriter out) {
+for (Map.Entry<Integer, Set<String>> e : map.entrySet()) {
+int count = e.getKey();
+Set<String> labels = e.getValue();
+for (String label : labels) {
+out.println(String.format("%6d: %s", count, label));
+}
+}
+}
+}
+}
+// </editor-fold>
+}

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/doclint/Messages.java

src/share/classes/com/sun/tools/doclint/Messages.java