/** * @(#)Log.java	1.26 03/01/23 * * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package com.sun.tools.javac.v8.util;import java.io.*;import java.util.ResourceBundle;import java.util.MissingResourceException;import java.text.MessageFormat;/** * A class for error logs. Reports errors and warnings, and *  keeps track of error numbers and positions. */public class Log implements LayoutCharacters {    /**     * The context key for the log.     */    private static final Context.Key logKey = new Context.Key();    /**     * The context key for the output PrintWriter.     */    public static final Context.Key outKey = new Context.Key();    public final PrintWriter errWriter;    public final PrintWriter warnWriter;    public final PrintWriter noticeWriter;    /**     * The maximum number of errors/warnings that are reported,     *  can be reassigned from outside.     */    private final int MaxErrors;    private final int MaxWarnings;    /**     * Switch: prompt user on each error.     */    public boolean promptOnError;    /**     * Switch: emit warning messages.     */    public boolean emitWarnings;    /**     * Construct a log with given I/O redirections.     */    protected Log(Context context, PrintWriter errWriter, PrintWriter warnWriter,            PrintWriter noticeWriter) {        super();        context.put(logKey, this);        this.errWriter = errWriter;        this.warnWriter = warnWriter;        this.noticeWriter = noticeWriter;        Options options = Options.instance(context);        this.promptOnError = options.get("-prompt") != null;        this.emitWarnings = options.get("-nowarn") == null;        this.sourcename = Name.Table.instance(context).__input;        this.MaxErrors = getIntOption(options, "-Xmaxerrs", 100);        this.MaxWarnings = getIntOption(options, "-Xmaxwarns", 100);    }    private int getIntOption(Options options, String optionName, int defaultValue) {        String s = (String) options.get(optionName);        try {            if (s != null)                return Integer.parseInt(s);        } catch (NumberFormatException e) {        }        return defaultValue;    }    /**      * The default writer for diagnostics      */    static final PrintWriter defaultWriter(Context context) {        PrintWriter result = (PrintWriter) context.get(outKey);        if (result == null)            context.put(outKey, result = new PrintWriter(System.err));        return result;    }    /**      * Construct a with default settings.      */    protected Log(Context context) {        this(context, defaultWriter(context));    }    /**      * Construct a 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 = (Log) context.get(logKey);        if (instance == null)            instance = new Log(context);        return instance;    }    /**      * The name of the file that's currently translated.      */    private Name sourcename;    /**     * The number of errors encountered so far.     */    public int nerrors = 0;    /**     * The number of warnings encountered so far.     */    public int nwarnings = 0;    /**     * A set of all errors generated so far. This is used to avoid printing an     *  error message more than once. For each error, a pair consisting of the     *  source file name and source code position of the errir is added to the set.     */    private Set recorded = Set.make();    /**     * The buffer containing the file that's currently translated.     */    private byte[] buf = null;    /**     * The position in the buffer at which last error was reported     */    private int bp;    /**     * the source line at which last error was reported.     */    private int lastLine;    /**     * Re-assign source name, returning previous setting.     */    public Name useSource(Name name) {        Name prev = sourcename;        sourcename = name;        if (prev != sourcename)            buf = null;        return prev;    }    /**      * Return current source name.      */    public Name currentSource() {        return sourcename;    }    /**      * Flush the logs      */    public void flush() {        errWriter.flush();        warnWriter.flush();        noticeWriter.flush();    }    /**      * Prompt user after an error.      */    public void prompt() {        if (promptOnError) {            System.err.println(getLocalizedString("resume.abort"));            char ch;            try {                while (true) {                    switch (System.in.read()) {                    case 'a':                    case 'A':                        System.exit(-1);                        return;                    case 'r':                    case 'R':                        return;                    case 'x':                    case 'X':                        throw new AssertionError("user abort");                    default:                    }                }            } catch (IOException e) {            }        }    }    /**      * Print a faulty source code line and point to the error.      *  @param line    The line number of the printed line in the current buffer.      *  @param col     The number of the column to be highlighted as error position.      */    private void printErrLine(int line, int col, PrintWriter writer) {        try {            if (buf == null) {                FileInputStream in = new FileInputStream(sourcename.toString());                buf = new byte[in.available()];                in.read(buf);                in.close();                bp = 0;                lastLine = 1;            } else if (lastLine > line) {                bp = 0;                lastLine = 1;            }            while (bp < buf.length && lastLine < line) {                switch (buf[bp]) {                case CR:                    bp++;                    if (bp < buf.length && buf[bp] == LF)                        bp++;                    lastLine++;                    break;                case LF:                    bp++;                    lastLine++;                    break;                default:                    bp++;                }            }            int lineEnd = bp;            while (lineEnd < buf.length && buf[lineEnd] != CR && buf[lineEnd] != LF)                lineEnd++;            printLines(writer, new String(buf, bp, lineEnd - bp));            if (col == 0)                col = 1;            byte[] ptr = new byte[col];            for (int i = 0; i < col - 1; i++)                ptr[i] = (byte)' ';            ptr[col - 1] = (byte)'^';            printLines(writer, new String(ptr, 0, col));        } catch (IOException e) {