| /* |
| * Copyright (c) 2005, 2012, 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.javac.util; |
| |
| import java.util.Collection; |
| import java.util.EnumMap; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.regex.Matcher; |
| import javax.tools.JavaFileObject; |
| |
| import com.sun.tools.javac.util.AbstractDiagnosticFormatter.SimpleConfiguration; |
| import com.sun.tools.javac.util.BasicDiagnosticFormatter.BasicConfiguration; |
| |
| import static com.sun.tools.javac.api.DiagnosticFormatter.PositionKind.*; |
| import static com.sun.tools.javac.util.BasicDiagnosticFormatter.BasicConfiguration.*; |
| import static com.sun.tools.javac.util.LayoutCharacters.*; |
| |
| /** |
| * A basic formatter for diagnostic messages. |
| * The basic formatter will format a diagnostic according to one of three format patterns, depending on whether |
| * or not the source name and position are set. The formatter supports a printf-like string for patterns |
| * with the following special characters: |
| * <ul> |
| * <li>%b: the base of the source name |
| * <li>%f: the source name (full absolute path) |
| * <li>%l: the line number of the diagnostic, derived from the character offset |
| * <li>%c: the column number of the diagnostic, derived from the character offset |
| * <li>%o: the character offset of the diagnostic if set |
| * <li>%p: the prefix for the diagnostic, derived from the diagnostic type |
| * <li>%t: the prefix as it normally appears in standard diagnostics. In this case, no prefix is |
| * shown if the type is ERROR and if a source name is set |
| * <li>%m: the text or the diagnostic, including any appropriate arguments |
| * <li>%_: space delimiter, useful for formatting purposes |
| * </ul> |
| * |
| * <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> |
| */ |
| public class BasicDiagnosticFormatter extends AbstractDiagnosticFormatter { |
| |
| /** |
| * Create a basic formatter based on the supplied options. |
| * |
| * @param options list of command-line options |
| * @param msgs JavacMessages object used for i18n |
| */ |
| public BasicDiagnosticFormatter(Options options, JavacMessages msgs) { |
| super(msgs, new BasicConfiguration(options)); |
| } |
| |
| /** |
| * Create a standard basic formatter |
| * |
| * @param msgs JavacMessages object used for i18n |
| */ |
| public BasicDiagnosticFormatter(JavacMessages msgs) { |
| super(msgs, new BasicConfiguration()); |
| } |
| |
| public String formatDiagnostic(JCDiagnostic d, Locale l) { |
| if (l == null) |
| l = messages.getCurrentLocale(); |
| String format = selectFormat(d); |
| StringBuilder buf = new StringBuilder(); |
| for (int i = 0; i < format.length(); i++) { |
| char c = format.charAt(i); |
| boolean meta = false; |
| if (c == '%' && i < format.length() - 1) { |
| meta = true; |
| c = format.charAt(++i); |
| } |
| buf.append(meta ? formatMeta(c, d, l) : String.valueOf(c)); |
| } |
| if (depth == 0) |
| return addSourceLineIfNeeded(d, buf.toString()); |
| else |
| return buf.toString(); |
| } |
| |
| public String formatMessage(JCDiagnostic d, Locale l) { |
| int currentIndentation = 0; |
| StringBuilder buf = new StringBuilder(); |
| Collection<String> args = formatArguments(d, l); |
| String msg = localize(l, d.getCode(), args.toArray()); |
| String[] lines = msg.split("\n"); |
| if (getConfiguration().getVisible().contains(DiagnosticPart.SUMMARY)) { |
| currentIndentation += getConfiguration().getIndentation(DiagnosticPart.SUMMARY); |
| buf.append(indent(lines[0], currentIndentation)); //summary |
| } |
| if (lines.length > 1 && getConfiguration().getVisible().contains(DiagnosticPart.DETAILS)) { |
| currentIndentation += getConfiguration().getIndentation(DiagnosticPart.DETAILS); |
| for (int i = 1;i < lines.length; i++) { |
| buf.append("\n" + indent(lines[i], currentIndentation)); |
| } |
| } |
| if (d.isMultiline() && getConfiguration().getVisible().contains(DiagnosticPart.SUBDIAGNOSTICS)) { |
| currentIndentation += getConfiguration().getIndentation(DiagnosticPart.SUBDIAGNOSTICS); |
| for (String sub : formatSubdiagnostics(d, l)) { |
| buf.append("\n" + indent(sub, currentIndentation)); |
| } |
| } |
| return buf.toString(); |
| } |
| |
| protected String addSourceLineIfNeeded(JCDiagnostic d, String msg) { |
| if (!displaySource(d)) |
| return msg; |
| else { |
| BasicConfiguration conf = getConfiguration(); |
| int indentSource = conf.getIndentation(DiagnosticPart.SOURCE); |
| String sourceLine = "\n" + formatSourceLine(d, indentSource); |
| boolean singleLine = msg.indexOf("\n") == -1; |
| if (singleLine || getConfiguration().getSourcePosition() == SourcePosition.BOTTOM) |
| return msg + sourceLine; |
| else |
| return msg.replaceFirst("\n", Matcher.quoteReplacement(sourceLine) + "\n"); |
| } |
| } |
| |
| protected String formatMeta(char c, JCDiagnostic d, Locale l) { |
| switch (c) { |
| case 'b': |
| return formatSource(d, false, l); |
| case 'e': |
| return formatPosition(d, END, l); |
| case 'f': |
| return formatSource(d, true, l); |
| case 'l': |
| return formatPosition(d, LINE, l); |
| case 'c': |
| return formatPosition(d, COLUMN, l); |
| case 'o': |
| return formatPosition(d, OFFSET, l); |
| case 'p': |
| return formatKind(d, l); |
| case 's': |
| return formatPosition(d, START, l); |
| case 't': { |
| boolean usePrefix; |
| switch (d.getType()) { |
| case FRAGMENT: |
| usePrefix = false; |
| break; |
| case ERROR: |
| usePrefix = (d.getIntPosition() == Position.NOPOS); |
| break; |
| default: |
| usePrefix = true; |
| } |
| if (usePrefix) |
| return formatKind(d, l); |
| else |
| return ""; |
| } |
| case 'm': |
| return formatMessage(d, l); |
| case 'L': |
| return formatLintCategory(d, l); |
| case '_': |
| return " "; |
| case '%': |
| return "%"; |
| default: |
| return String.valueOf(c); |
| } |
| } |
| |
| private String selectFormat(JCDiagnostic d) { |
| DiagnosticSource source = d.getDiagnosticSource(); |
| String format = getConfiguration().getFormat(BasicFormatKind.DEFAULT_NO_POS_FORMAT); |
| if (source != null && source != DiagnosticSource.NO_SOURCE) { |
| if (d.getIntPosition() != Position.NOPOS) { |
| format = getConfiguration().getFormat(BasicFormatKind.DEFAULT_POS_FORMAT); |
| } else if (source.getFile() != null && |
| source.getFile().getKind() == JavaFileObject.Kind.CLASS) { |
| format = getConfiguration().getFormat(BasicFormatKind.DEFAULT_CLASS_FORMAT); |
| } |
| } |
| return format; |
| } |
| |
| @Override |
| public BasicConfiguration getConfiguration() { |
| //the following cast is always safe - see init |
| return (BasicConfiguration)super.getConfiguration(); |
| } |
| |
| static public class BasicConfiguration extends SimpleConfiguration { |
| |
| protected Map<DiagnosticPart, Integer> indentationLevels; |
| protected Map<BasicFormatKind, String> availableFormats; |
| protected SourcePosition sourcePosition; |
| |
| @SuppressWarnings("fallthrough") |
| public BasicConfiguration(Options options) { |
| super(options, EnumSet.of(DiagnosticPart.SUMMARY, |
| DiagnosticPart.DETAILS, |
| DiagnosticPart.SUBDIAGNOSTICS, |
| DiagnosticPart.SOURCE)); |
| initFormat(); |
| initIndentation(); |
| if (options.isSet("oldDiags")) |
| initOldFormat(); |
| String fmt = options.get("diagsFormat"); |
| if (fmt != null) { |
| if (fmt.equals("OLD")) |
| initOldFormat(); |
| else |
| initFormats(fmt); |
| } |
| String srcPos = null; |
| if ((((srcPos = options.get("sourcePosition")) != null)) && |
| srcPos.equals("bottom")) |
| setSourcePosition(SourcePosition.BOTTOM); |
| else |
| setSourcePosition(SourcePosition.AFTER_SUMMARY); |
| String indent = options.get("diagsIndentation"); |
| if (indent != null) { |
| String[] levels = indent.split("\\|"); |
| try { |
| switch (levels.length) { |
| case 5: |
| setIndentation(DiagnosticPart.JLS, |
| Integer.parseInt(levels[4])); |
| case 4: |
| setIndentation(DiagnosticPart.SUBDIAGNOSTICS, |
| Integer.parseInt(levels[3])); |
| case 3: |
| setIndentation(DiagnosticPart.SOURCE, |
| Integer.parseInt(levels[2])); |
| case 2: |
| setIndentation(DiagnosticPart.DETAILS, |
| Integer.parseInt(levels[1])); |
| default: |
| setIndentation(DiagnosticPart.SUMMARY, |
| Integer.parseInt(levels[0])); |
| } |
| } |
| catch (NumberFormatException ex) { |
| initIndentation(); |
| } |
| } |
| } |
| |
| public BasicConfiguration() { |
| super(EnumSet.of(DiagnosticPart.SUMMARY, |
| DiagnosticPart.DETAILS, |
| DiagnosticPart.SUBDIAGNOSTICS, |
| DiagnosticPart.SOURCE)); |
| initFormat(); |
| initIndentation(); |
| } |
| |
| private void initFormat() { |
| initFormats("%f:%l:%_%p%L%m", "%p%L%m", "%f:%_%p%L%m"); |
| } |
| |
| private void initOldFormat() { |
| initFormats("%f:%l:%_%t%L%m", "%p%L%m", "%f:%_%t%L%m"); |
| } |
| |
| private void initFormats(String pos, String nopos, String clazz) { |
| availableFormats = new EnumMap<BasicFormatKind, String>(BasicFormatKind.class); |
| setFormat(BasicFormatKind.DEFAULT_POS_FORMAT, pos); |
| setFormat(BasicFormatKind.DEFAULT_NO_POS_FORMAT, nopos); |
| setFormat(BasicFormatKind.DEFAULT_CLASS_FORMAT, clazz); |
| } |
| |
| @SuppressWarnings("fallthrough") |
| private void initFormats(String fmt) { |
| String[] formats = fmt.split("\\|"); |
| switch (formats.length) { |
| case 3: |
| setFormat(BasicFormatKind.DEFAULT_CLASS_FORMAT, formats[2]); |
| case 2: |
| setFormat(BasicFormatKind.DEFAULT_NO_POS_FORMAT, formats[1]); |
| default: |
| setFormat(BasicFormatKind.DEFAULT_POS_FORMAT, formats[0]); |
| } |
| } |
| |
| private void initIndentation() { |
| indentationLevels = new HashMap<DiagnosticPart, Integer>(); |
| setIndentation(DiagnosticPart.SUMMARY, 0); |
| setIndentation(DiagnosticPart.DETAILS, DetailsInc); |
| setIndentation(DiagnosticPart.SUBDIAGNOSTICS, DiagInc); |
| setIndentation(DiagnosticPart.SOURCE, 0); |
| } |
| |
| /** |
| * Get the amount of spaces for a given indentation kind |
| * @param diagPart the diagnostic part for which the indentation is |
| * to be retrieved |
| * @return the amount of spaces used for the specified indentation kind |
| */ |
| public int getIndentation(DiagnosticPart diagPart) { |
| return indentationLevels.get(diagPart); |
| } |
| |
| /** |
| * Set the indentation level for various element of a given diagnostic - |
| * this might lead to more readable diagnostics |
| * |
| * @param diagPart |
| * @param nSpaces amount of spaces for the specified diagnostic part |
| */ |
| public void setIndentation(DiagnosticPart diagPart, int nSpaces) { |
| indentationLevels.put(diagPart, nSpaces); |
| } |
| |
| /** |
| * Set the source line positioning used by this formatter |
| * |
| * @param sourcePos a positioning value for source line |
| */ |
| public void setSourcePosition(SourcePosition sourcePos) { |
| sourcePosition = sourcePos; |
| } |
| |
| /** |
| * Get the source line positioning used by this formatter |
| * |
| * @return the positioning value used by this formatter |
| */ |
| public SourcePosition getSourcePosition() { |
| return sourcePosition; |
| } |
| //where |
| /** |
| * A source positioning value controls the position (within a given |
| * diagnostic message) in which the source line the diagnostic refers to |
| * should be displayed (if applicable) |
| */ |
| public enum SourcePosition { |
| /** |
| * Source line is displayed after the diagnostic message |
| */ |
| BOTTOM, |
| /** |
| * Source line is displayed after the first line of the diagnostic |
| * message |
| */ |
| AFTER_SUMMARY; |
| } |
| |
| /** |
| * Set a metachar string for a specific format |
| * |
| * @param kind the format kind to be set |
| * @param s the metachar string specifying the format |
| */ |
| public void setFormat(BasicFormatKind kind, String s) { |
| availableFormats.put(kind, s); |
| } |
| |
| /** |
| * Get a metachar string for a specific format |
| * |
| * @param kind the format kind for which to get the metachar string |
| */ |
| public String getFormat(BasicFormatKind kind) { |
| return availableFormats.get(kind); |
| } |
| //where |
| /** |
| * This enum contains all the kinds of formatting patterns supported |
| * by a basic diagnostic formatter. |
| */ |
| public enum BasicFormatKind { |
| /** |
| * A format string to be used for diagnostics with a given position. |
| */ |
| DEFAULT_POS_FORMAT, |
| /** |
| * A format string to be used for diagnostics without a given position. |
| */ |
| DEFAULT_NO_POS_FORMAT, |
| /** |
| * A format string to be used for diagnostics regarding classfiles |
| */ |
| DEFAULT_CLASS_FORMAT; |
| } |
| } |
| } |
