1 /*
   2  * Copyright (c) 2009, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package org.graalvm.compiler.debug;
  26 
  27 import java.io.IOException;
  28 import java.io.OutputStream;
  29 import java.io.PrintStream;
  30 
  31 /**
  32  * A utility for printing compiler debug and informational output to an output stream.
  33  *
  34  * A {@link LogStream} instance maintains an internal buffer that is flushed to the underlying
  35  * output stream every time one of the {@code println} methods is invoked, or a newline character (
  36  * {@code '\n'}) is written.
  37  *
  38  * All of the {@code print} and {@code println} methods return the {code LogStream} instance on
  39  * which they were invoked. This allows chaining of these calls to mitigate use of String
  40  * concatenation by the caller.
  41  *
  42  * A {@code LogStream} maintains a current {@linkplain #indentationLevel() indentation} level. Each
  43  * line of output written to this stream has {@code n} spaces prefixed to it where {@code n} is the
  44  * value that would be returned by {@link #indentationLevel()} when the first character of a new
  45  * line is written.
  46  *
  47  * A {@code LogStream} maintains a current {@linkplain #position() position} for the current line
  48  * being written. This position can be advanced to a specified position by
  49  * {@linkplain #fillTo(int, char) filling} this stream with a given character.
  50  */
  51 public class LogStream {
  52 
  53     /**
  54      * Null output stream that simply swallows any output sent to it.
  55      */
  56     public static final LogStream SINK = new LogStream();
  57 
  58     private static final PrintStream SINK_PS = new PrintStream(new OutputStream() {
  59 
  60         @Override
  61         public void write(int b) throws IOException {
  62         }
  63     });
  64 
  65     private LogStream() {
  66         this.ps = null;
  67         this.lineBuffer = null;
  68     }
  69 
  70     /**
  71      * The output stream to which this log stream writes.
  72      */
  73     private final PrintStream ps;
  74 
  75     private final StringBuilder lineBuffer;
  76     private int indentationLevel;
  77     private char indentation = ' ';
  78     private boolean indentationDisabled;
  79 
  80     public final PrintStream out() {
  81         if (ps == null) {
  82             return SINK_PS;
  83         }
  84         return ps;
  85     }
  86 
  87     /**
  88      * The system dependent line separator.
  89      */
  90     public static final String LINE_SEPARATOR = System.getProperty("line.separator");
  91 
  92     /**
  93      * Creates a new log stream.
  94      *
  95      * @param os the underlying output stream to which prints are sent
  96      */
  97     public LogStream(OutputStream os) {
  98         ps = os instanceof PrintStream ? (PrintStream) os : new PrintStream(os);
  99         lineBuffer = new StringBuilder(100);
 100     }
 101 
 102     /**
 103      * Creates a new log stream that shares the same {@linkplain #ps output stream} as a given
 104      * {@link LogStream}.
 105      *
 106      * @param log a LogStream whose output stream is shared with this one
 107      */
 108     public LogStream(LogStream log) {
 109         ps = log.ps;
 110         lineBuffer = new StringBuilder(100);
 111     }
 112 
 113     /**
 114      * Prepends {@link #indentation} to the current output line until its write position is equal to
 115      * the current {@linkplain #indentationLevel()} level.
 116      */
 117     private void indent() {
 118         if (ps != null) {
 119             if (!indentationDisabled && indentationLevel != 0) {
 120                 while (lineBuffer.length() < indentationLevel) {
 121                     lineBuffer.append(indentation);
 122                 }
 123             }
 124         }
 125     }
 126 
 127     private LogStream flushLine(boolean withNewline) {
 128         if (ps != null) {
 129             if (withNewline) {
 130                 lineBuffer.append(LINE_SEPARATOR);
 131             }
 132             ps.print(lineBuffer.toString());
 133             ps.flush();
 134             lineBuffer.setLength(0);
 135         }
 136         return this;
 137     }
 138 
 139     /**
 140      * Flushes the stream. This is done by terminating the current line if it is not at position 0
 141      * and then flushing the underlying output stream.
 142      */
 143     public void flush() {
 144         if (ps != null) {
 145             if (lineBuffer.length() != 0) {
 146                 flushLine(false);
 147             }
 148             ps.flush();
 149         }
 150     }
 151 
 152     /**
 153      * Gets the current column position of this log stream.
 154      *
 155      * @return the current column position of this log stream
 156      */
 157     public int position() {
 158         return lineBuffer == null ? 0 : lineBuffer.length();
 159 
 160     }
 161 
 162     /**
 163      * Gets the current indentation level for this log stream.
 164      *
 165      * @return the current indentation level for this log stream.
 166      */
 167     public int indentationLevel() {
 168         return indentationLevel;
 169     }
 170 
 171     /**
 172      * Adjusts the current indentation level of this log stream.
 173      *
 174      * @param delta
 175      */
 176     public void adjustIndentation(int delta) {
 177         if (delta < 0) {
 178             indentationLevel = Math.max(0, indentationLevel + delta);
 179         } else {
 180             indentationLevel += delta;
 181         }
 182     }
 183 
 184     /**
 185      * Gets the current indentation character of this log stream.
 186      */
 187     public char indentation() {
 188         return indentation;
 189     }
 190 
 191     public void disableIndentation() {
 192         indentationDisabled = true;
 193     }
 194 
 195     public void enableIndentation() {
 196         indentationDisabled = false;
 197     }
 198 
 199     /**
 200      * Sets the character used for indentation.
 201      */
 202     public void setIndentation(char c) {
 203         indentation = c;
 204     }
 205 
 206     /**
 207      * Advances this stream's {@linkplain #position() position} to a given position by repeatedly
 208      * appending a given character as necessary.
 209      *
 210      * @param position the position to which this stream's position will be advanced
 211      * @param filler the character used to pad the stream
 212      */
 213     public LogStream fillTo(int position, char filler) {
 214         if (ps != null) {
 215             indent();
 216             while (lineBuffer.length() < position) {
 217                 lineBuffer.append(filler);
 218             }
 219         }
 220         return this;
 221     }
 222 
 223     /**
 224      * Writes a boolean value to this stream as {@code "true"} or {@code "false"}.
 225      *
 226      * @param b the value to be printed
 227      * @return this {@link LogStream} instance
 228      */
 229     public LogStream print(boolean b) {
 230         if (ps != null) {
 231             indent();
 232             lineBuffer.append(b);
 233         }
 234         return this;
 235     }
 236 
 237     /**
 238      * Writes a boolean value to this stream followed by a {@linkplain #LINE_SEPARATOR line
 239      * separator}.
 240      *
 241      * @param b the value to be printed
 242      * @return this {@link LogStream} instance
 243      */
 244     public LogStream println(boolean b) {
 245         if (ps != null) {
 246             indent();
 247             lineBuffer.append(b);
 248             return flushLine(true);
 249         }
 250         return this;
 251     }
 252 
 253     /**
 254      * Writes a character value to this stream.
 255      *
 256      * @param c the value to be printed
 257      * @return this {@link LogStream} instance
 258      */
 259     public LogStream print(char c) {
 260         if (ps != null) {
 261             indent();
 262             lineBuffer.append(c);
 263             if (c == '\n') {
 264                 if (lineBuffer.indexOf(LINE_SEPARATOR, lineBuffer.length() - LINE_SEPARATOR.length()) != -1) {
 265                     flushLine(false);
 266                 }
 267             }
 268         }
 269         return this;
 270     }
 271 
 272     /**
 273      * Writes a character value to this stream followed by a {@linkplain #LINE_SEPARATOR line
 274      * separator}.
 275      *
 276      * @param c the value to be printed
 277      * @return this {@link LogStream} instance
 278      */
 279     public LogStream println(char c) {
 280         if (ps != null) {
 281             indent();
 282             lineBuffer.append(c);
 283             flushLine(true);
 284         }
 285         return this;
 286     }
 287 
 288     /**
 289      * Prints an int value.
 290      *
 291      * @param i the value to be printed
 292      * @return this {@link LogStream} instance
 293      */
 294     public LogStream print(int i) {
 295         if (ps != null) {
 296             indent();
 297             lineBuffer.append(i);
 298         }
 299         return this;
 300     }
 301 
 302     /**
 303      * Writes an int value to this stream followed by a {@linkplain #LINE_SEPARATOR line separator}.
 304      *
 305      * @param i the value to be printed
 306      * @return this {@link LogStream} instance
 307      */
 308     public LogStream println(int i) {
 309         if (ps != null) {
 310             indent();
 311             lineBuffer.append(i);
 312             return flushLine(true);
 313         }
 314         return this;
 315     }
 316 
 317     /**
 318      * Writes a float value to this stream.
 319      *
 320      * @param f the value to be printed
 321      * @return this {@link LogStream} instance
 322      */
 323     public LogStream print(float f) {
 324         if (ps != null) {
 325             indent();
 326             lineBuffer.append(f);
 327         }
 328         return this;
 329     }
 330 
 331     /**
 332      * Writes a float value to this stream followed by a {@linkplain #LINE_SEPARATOR line separator}
 333      * .
 334      *
 335      * @param f the value to be printed
 336      * @return this {@link LogStream} instance
 337      */
 338     public LogStream println(float f) {
 339         if (ps != null) {
 340             indent();
 341             lineBuffer.append(f);
 342             return flushLine(true);
 343         }
 344         return this;
 345     }
 346 
 347     /**
 348      * Writes a long value to this stream.
 349      *
 350      * @param l the value to be printed
 351      * @return this {@link LogStream} instance
 352      */
 353     public LogStream print(long l) {
 354         if (ps != null) {
 355             indent();
 356             lineBuffer.append(l);
 357         }
 358         return this;
 359     }
 360 
 361     /**
 362      * Writes a long value to this stream followed by a {@linkplain #LINE_SEPARATOR line separator}.
 363      *
 364      * @param l the value to be printed
 365      * @return this {@link LogStream} instance
 366      */
 367     public LogStream println(long l) {
 368         if (ps != null) {
 369             indent();
 370             lineBuffer.append(l);
 371             return flushLine(true);
 372         }
 373         return this;
 374     }
 375 
 376     /**
 377      * Writes a double value to this stream.
 378      *
 379      * @param d the value to be printed
 380      * @return this {@link LogStream} instance
 381      */
 382     public LogStream print(double d) {
 383         if (ps != null) {
 384             indent();
 385             lineBuffer.append(d);
 386         }
 387         return this;
 388     }
 389 
 390     /**
 391      * Writes a double value to this stream followed by a {@linkplain #LINE_SEPARATOR line
 392      * separator}.
 393      *
 394      * @param d the value to be printed
 395      * @return this {@link LogStream} instance
 396      */
 397     public LogStream println(double d) {
 398         if (ps != null) {
 399             indent();
 400             lineBuffer.append(d);
 401             return flushLine(true);
 402         }
 403         return this;
 404     }
 405 
 406     /**
 407      * Writes a {@code String} value to this stream. This method ensures that the
 408      * {@linkplain #position() position} of this stream is updated correctly with respect to any
 409      * {@linkplain #LINE_SEPARATOR line separators} present in {@code s}.
 410      *
 411      * @param s the value to be printed
 412      * @return this {@link LogStream} instance
 413      */
 414     public LogStream print(String s) {
 415         if (ps != null) {
 416             if (s == null) {
 417                 indent();
 418                 lineBuffer.append(s);
 419                 return this;
 420             }
 421 
 422             int index = 0;
 423             int next = s.indexOf(LINE_SEPARATOR, index);
 424             while (index < s.length()) {
 425                 indent();
 426                 if (next > index || next == 0) {
 427                     lineBuffer.append(s.substring(index, next));
 428                     flushLine(true);
 429                     index = next + LINE_SEPARATOR.length();
 430                     next = s.indexOf(LINE_SEPARATOR, index);
 431                 } else {
 432                     lineBuffer.append(s.substring(index));
 433                     break;
 434                 }
 435             }
 436         }
 437         return this;
 438     }
 439 
 440     /**
 441      * Writes a {@code String} value to this stream followed by a {@linkplain #LINE_SEPARATOR line
 442      * separator}.
 443      *
 444      * @param s the value to be printed
 445      * @return this {@link LogStream} instance
 446      */
 447     public LogStream println(String s) {
 448         if (ps != null) {
 449             print(s);
 450             flushLine(true);
 451         }
 452         return this;
 453     }
 454 
 455     /**
 456      * Writes a formatted string to this stream.
 457      *
 458      * @param format a format string as described in {@link String#format(String, Object...)}
 459      * @param args the arguments to be formatted
 460      * @return this {@link LogStream} instance
 461      */
 462     public LogStream printf(String format, Object... args) {
 463         if (ps != null) {
 464             print(String.format(format, args));
 465         }
 466         return this;
 467     }
 468 
 469     /**
 470      * Writes a {@linkplain #LINE_SEPARATOR line separator} to this stream.
 471      *
 472      * @return this {@code LogStream} instance
 473      */
 474     public LogStream println() {
 475         if (ps != null) {
 476             indent();
 477             flushLine(true);
 478         }
 479         return this;
 480     }
 481 }