jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/util/Log.java

equal deleted inserted replaced

-:ba38ad2dd137
+:4995ab1a4558
 /*
-* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2016, 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
 package com.sun.tools.javac.util;
 import java.io.*;
 import java.util.Arrays;
+import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
 import javax.tools.DiagnosticListener;
 import javax.tools.JavaFileObject;
 import com.sun.tools.javac.api.DiagnosticFormatter;
 import com.sun.tools.javac.main.Main;
 */
 public class Log extends AbstractLog {
 /** The context key for the log. */
 public static final Context.Key<Log> logKey = new Context.Key<>();
-/** The context key for the output PrintWriter. */
+/** The context key for the standard output PrintWriter. */
 public static final Context.Key<PrintWriter> outKey = new Context.Key<>();
+/** The context key for the diagnostic PrintWriter. */
+public static final Context.Key<PrintWriter> errKey = new Context.Key<>();
 /* TODO: Should unify this with prefix handling in JCDiagnostic.Factory. */
 public enum PrefixKind {
 JAVAC("javac."),
 COMPILER_MISC("compiler.misc.");
 public static class DiscardDiagnosticHandler extends DiagnosticHandler {
 public DiscardDiagnosticHandler(Log log) {
 install(log);
 }
+@Override
 public void report(JCDiagnostic diag) { }
 }
 /**
 * A DiagnosticHandler that can defer some or all diagnostics,
 public DeferredDiagnosticHandler(Log log, Filter<JCDiagnostic> filter) {
 this.filter = filter;
 install(log);
 }
+@Override
 public void report(JCDiagnostic diag) {
 if (!diag.isFlagSet(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE) &&
 (filter == null || filter.accepts(diag))) {
 deferred.add(diag);
 } else {
 }
 deferred = null; // prevent accidental ongoing use
 }
 }
-public enum WriterKind { NOTICE, WARNING, ERROR }
+public enum WriterKind { NOTICE, WARNING, ERROR, STDOUT, STDERR }
-protected PrintWriter errWriter;
+private final Map<WriterKind, PrintWriter> writers;
-protected PrintWriter warnWriter;
-protected PrintWriter noticeWriter;
 /** The maximum number of errors/warnings that are reported.
 */
 protected int MaxErrors;
 protected int MaxWarnings;
 /**
 * Handler for initial dispatch of diagnostics.
 */
 private DiagnosticHandler diagnosticHandler;
-/** Construct a log with given I/O redirections.
+/** Get the Log instance for this context. */
-*/
+public static Log instance(Context context) {
+Log instance = context.get(logKey);
+if (instance == null)
+instance = new Log(context);
+return instance;
+}
+/**
+* Register a Context.Factory to create a Log.
+*/
+public static void preRegister(Context context, PrintWriter w) {
+context.put(Log.class, (Context.Factory<Log>) (c -> new Log(c, w)));
+}
+/**
+* Construct a log with default settings.
+* If no streams are set in the context, the log will be initialized to use
+* System.out for normal output, and System.err for all diagnostic output.
+* If one stream is set in the context, with either Log.outKey or Log.errKey,
+* it will be used for all output.
+* Otherwise, the log will be initialized to use both streams found in the context.
+*/
+protected Log(Context context) {
+this(context, initWriters(context));
+}
+/**
+* Initialize a map of writers based on values found in the context
+* @param context the context in which to find writers to use
+* @return a map of writers
+*/
+private static Map<WriterKind, PrintWriter> initWriters(Context context) {
+PrintWriter out = context.get(outKey);
+PrintWriter err = context.get(errKey);
+if (out == null && err == null) {
+out = new PrintWriter(System.out, true);
+err = new PrintWriter(System.err, true);
+return initWriters(out, err);
+} else if (out == null || err == null) {
+PrintWriter pw = (out != null) ? out : err;
+return initWriters(pw, pw);
+} else {
+return initWriters(out, err);
+}
+}
+/**
+* Construct a log with all output sent to a single output stream.
+*/
+protected Log(Context context, PrintWriter writer) {
+this(context, initWriters(writer, writer));
+}
+/**
+* Construct a log.
+* The log will be initialized to use stdOut for normal output, and stdErr
+* for all diagnostic output.
+*/
+protected Log(Context context, PrintWriter out, PrintWriter err) {
+this(context, initWriters(out, err));
+}
+/**
+* Initialize a writer map for a stream for normal output, and a stream for diagnostics.
+* @param out a stream to be used for normal output
+* @param err a stream to be used for diagnostic messages, such as errors, warnings, etc
+* @return a map of writers
+*/
+private static Map<WriterKind, PrintWriter> initWriters(PrintWriter out, PrintWriter err) {
+Map<WriterKind, PrintWriter> writers = new EnumMap<>(WriterKind.class);
+writers.put(WriterKind.ERROR, err);
+writers.put(WriterKind.WARNING, err);
+writers.put(WriterKind.NOTICE, err);
+writers.put(WriterKind.STDOUT, out);
+writers.put(WriterKind.STDERR, err);
+return writers;
+}
+/**
+* Construct a log with given I/O redirections.
+* @deprecated
+* This constructor is provided to support the supported but now-deprecated javadoc entry point
+*      com.sun.tools.javadoc.Main.execute(String programName,
+*          PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter,
+*          String defaultDocletClassName, String... args)
+*/
+@Deprecated
 protected Log(Context context, PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter) {
+this(context, initWriters(errWriter, warnWriter, noticeWriter));
+}
+/**
+* Initialize a writer map with different streams for different types of diagnostics.
+* @param errWriter a stream for writing error messages
+* @param warnWriter a stream for writing warning messages
+* @param noticeWriter a stream for writing notice messages
+* @return a map of writers
+* @deprecated This method exists to support a supported but now deprecated javadoc entry point.
+*/
+@Deprecated
+private static Map<WriterKind, PrintWriter>  initWriters(PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter) {
+Map<WriterKind, PrintWriter> writers = new EnumMap<>(WriterKind.class);
+writers.put(WriterKind.ERROR, errWriter);
+writers.put(WriterKind.WARNING, warnWriter);
+writers.put(WriterKind.NOTICE, noticeWriter);
+writers.put(WriterKind.STDOUT, noticeWriter);
+writers.put(WriterKind.STDERR, errWriter);
+return writers;
+}
+/**
+* Creates a log.
+* @param context the context in which the log should be registered
+* @param writers a map of writers that can be accessed by the kind of writer required
+*/
+private Log(Context context, Map<WriterKind, PrintWriter> writers) {
 super(JCDiagnostic.Factory.instance(context));
 context.put(logKey, this);
-this.errWriter = errWriter;
+this.writers = writers;
-this.warnWriter = warnWriter;
-this.noticeWriter = noticeWriter;
 @SuppressWarnings("unchecked") // FIXME
 DiagnosticListener<? super JavaFileObject> dl =
 context.get(DiagnosticListener.class);
 this.diagListener = dl;
 messages.add(Main.javacBundleName);
 final Options options = Options.instance(context);
 initOptions(options);
 options.addListener(new Runnable() {
+@Override
 public void run() {
 initOptions(options);
 }
 });
 }
 */
 protected int getDefaultMaxWarnings() {
 return 100;
 }
-/** The default writer for diagnostics
-*/
-static PrintWriter defaultWriter(Context context) {
-PrintWriter result = context.get(outKey);
-if (result == null)
-context.put(outKey, result = new PrintWriter(System.err));
-return result;
-}
-/** Construct a log with default settings.
-*/
-protected Log(Context context) {
-this(context, defaultWriter(context));
-}
-/** Construct a log with all output redirected.
-*/
-protected Log(Context context, PrintWriter defaultWriter) {
-this(context, defaultWriter, defaultWriter, defaultWriter);
-}
-/** Get the Log instance for this context. */
-public static Log instance(Context context) {
-Log instance = context.get(logKey);
-if (instance == null)
-instance = new Log(context);
-return instance;
-}
-/**
-* Register a Context.Factory to create a Log.
-*/
-public static void preRegister(Context context, PrintWriter w) {
-context.put(Log.class, (Context.Factory<Log>) (c -> new Log(c, w)));
-}
 /** The number of errors encountered so far.
 */
 public int nerrors = 0;
 /** The number of warnings encountered so far.
 public void setDiagnosticFormatter(DiagnosticFormatter<JCDiagnostic> diagFormatter) {
 this.diagFormatter = diagFormatter;
 }
 public PrintWriter getWriter(WriterKind kind) {
-switch (kind) {
+return writers.get(kind);
-case NOTICE:    return noticeWriter;
-case WARNING:   return warnWriter;
-case ERROR:     return errWriter;
-default:        throw new IllegalArgumentException();
-}
 }
 public void setWriter(WriterKind kind, PrintWriter pw) {
 Assert.checkNonNull(pw);
-switch (kind) {
+writers.put(kind, pw);
-case NOTICE:    noticeWriter = pw;  break;
-case WARNING:   warnWriter = pw;    break;
-case ERROR:     errWriter = pw;     break;
-default:        throw new IllegalArgumentException();
-}
 }
 public void setWriters(PrintWriter pw) {
-noticeWriter = warnWriter = errWriter = Assert.checkNonNull(pw);
+Assert.checkNonNull(pw);
+for (WriterKind k: WriterKind.values())
+writers.put(k, pw);
 }
 /**
 * Replace the specified diagnostic handler with the
 * handler that was current at the time this handler was created.
 }
 /** Flush the logs
 */
 public void flush() {
-errWriter.flush();
+for (PrintWriter pw: writers.values()) {
-warnWriter.flush();
+pw.flush();
-noticeWriter.flush();
+}
 }
 public void flush(WriterKind kind) {
 getWriter(kind).flush();
 }
 writer.println("^");
 writer.flush();
 }
 public void printNewline() {
+PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
 noticeWriter.println();
 }
 public void printNewline(WriterKind wk) {
 getWriter(wk).println();
 }
 public void printLines(String key, Object... args) {
+PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
 printRawLines(noticeWriter, localize(key, args));
 }
 public void printLines(PrefixKind pk, String key, Object... args) {
+PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
 printRawLines(noticeWriter, localize(pk, key, args));
 }
 public void printLines(WriterKind wk, String key, Object... args) {
 printRawLines(getWriter(wk), localize(key, args));
 /** Print the text of a message, translating newlines appropriately
 *  for the platform.
 */
 public void printRawLines(String msg) {
+PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
 printRawLines(noticeWriter, msg);
 }
 /** Print the text of a message, translating newlines appropriately
 *  for the platform.
 /**
 * Print the localized text of a "verbose" message to the
 * noticeWriter stream.
 */
 public void printVerbose(String key, Object... args) {
+PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
 printRawLines(noticeWriter, localize("verbose." + key, args));
 }
+@Override
 protected void directError(String key, Object... args) {
+PrintWriter errWriter = writers.get(WriterKind.ERROR);
 printRawLines(errWriter, localize(key, args));
 errWriter.flush();
 }
 /** Report a warning that cannot be suppressed.
 /**
 * Primary method to report a diagnostic.
 * @param diagnostic
 */
+@Override
 public void report(JCDiagnostic diagnostic) {
 diagnosticHandler.report(diagnostic);
 }
 /**
 * Common diagnostic handling.
 * The diagnostic is counted, and depending on the options and how many diagnostics have been
 * reported so far, the diagnostic may be handed off to writeDiagnostic.
 */
 private class DefaultDiagnosticHandler extends DiagnosticHandler {
+@Override
 public void report(JCDiagnostic diagnostic) {
 if (expectDiagKeys != null)
 expectDiagKeys.remove(diagnostic.getCode());
 switch (diagnostic.getType()) {
 switch (dt) {
 case FRAGMENT:
 throw new IllegalArgumentException();
 case NOTE:
-return noticeWriter;
+return writers.get(WriterKind.NOTICE);
 case WARNING:
-return warnWriter;
+return writers.get(WriterKind.WARNING);
 case ERROR:
-return errWriter;
+return writers.get(WriterKind.ERROR);
 default:
 throw new Error();
 }
 }
 * and quick prototyping
 ***************************************************************************/
 /** print an error or warning message:
 */
-private void printRawError(int pos, String msg) {
+private void printRawDiag(PrintWriter pw, String prefix, int pos, String msg) {
 if (source == null || pos == Position.NOPOS) {
-printRawLines(errWriter, "error: " + msg);
+printRawLines(pw, prefix + msg);
 } else {
 int line = source.getLineNumber(pos);
 JavaFileObject file = source.getFile();
 if (file != null)
-printRawLines(errWriter,
+printRawLines(pw,
 file.getName() + ":" +
 line + ": " + msg);
-printErrLine(pos, errWriter);
+printErrLine(pos, pw);
 }
-errWriter.flush();
+pw.flush();
 }
 /** report an error:
 */
 public void rawError(int pos, String msg) {
+PrintWriter errWriter = writers.get(WriterKind.ERROR);
 if (nerrors < MaxErrors && shouldReport(currentSourceFile(), pos)) {
-printRawError(pos, msg);
+printRawDiag(errWriter, "error: ", pos, msg);
 prompt();
 nerrors++;
 }
 errWriter.flush();
 }
 /** report a warning:
 */
 public void rawWarning(int pos, String msg) {
+PrintWriter warnWriter = writers.get(WriterKind.ERROR);
 if (nwarnings < MaxWarnings && emitWarnings) {
-printRawError(pos, "warning: " + msg);
+printRawDiag(warnWriter, "warning: ", pos, msg);
 }
 prompt();
 nwarnings++;
-errWriter.flush();
+warnWriter.flush();
 }
 public static String format(String fmt, Object... args) {
 return String.format((java.util.Locale)null, fmt, args);
 }

changeset 40232	4995ab1a4558
parent 32799	ee577901f4bb
child 40308	274367a99f98