repo/nabble: src/nabble/naml/compiler/PrintWriter.java comparison

comparison src/nabble/naml/compiler/PrintWriter.java @ 0:7ecd1a4ef557

add content

author	Franklin Schmidt <fschmidt@gmail.com>
date	Thu, 21 Mar 2019 19:15:52 -0600
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:7ecd1a4ef557
+/**
+* %W% %E%
+*
+* Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+*/
+package nabble.naml.compiler;
+import java.io.Writer;
+import java.io.PrintStream;
+import java.io.OutputStream;
+import java.io.FileNotFoundException;
+import java.io.UnsupportedEncodingException;
+import java.io.File;
+import java.io.IOException;
+import java.io.BufferedWriter;
+import java.io.OutputStreamWriter;
+import java.io.FileOutputStream;
+import java.io.InterruptedIOException;
+import java.util.Formatter;
+import java.util.Locale;
+/**
+* Prints formatted representations of objects to a text-output stream.  This
+* class implements all of the <tt>print</tt> methods found in {@link
+* PrintStream}.  It does not contain methods for writing raw bytes, for which
+* a program should use unencoded byte streams.
+*
+* <p> Unlike the {@link PrintStream} class, if automatic flushing is enabled
+* it will be done only when one of the <tt>println</tt>, <tt>printf</tt>, or
+* <tt>format</tt> methods is invoked, rather than whenever a newline character
+* happens to be output.  These methods use the platform's own notion of line
+* separator rather than the newline character.
+*
+* <p> Methods in this class never throw I/O exceptions, although some of its
+* constructors may.  The client may inquire as to whether any errors have
+* occurred by invoking {@link #checkError checkError()}.
+*
+* @version 	%I%, %G%
+* @author	Frank Yellin
+* @author	Mark Reinhold
+* @since	JDK1.1
+*/
+public class PrintWriter extends Writer implements IPrintWriter {
+	// added -fschmidt
+	public PrintWriter getPrintWriter() {
+		return this;
+	}
+	public void print(Boolean b) {
+		print((Object)b);
+	}
+/**
+* The underlying character-output stream of this
+* <code>PrintWriter</code>.
+*
+* @since 1.2
+*/
+protected Writer out;
+private boolean autoFlush = false;
+private boolean trouble = false;
+private Formatter formatter;
+private PrintStream psOut = null;
+/**
+* Line separator string.  This is the value of the line.separator
+* property at the moment that the stream was created.
+*/
+private static final String lineSeparator = System.getProperty("line.separator");
+/**
+* Creates a new PrintWriter, without automatic line flushing.
+*
+* @param  out        A character-output stream
+*/
+public PrintWriter (Writer out) {
+	this(out, false);
+}
+/**
+* Creates a new PrintWriter.
+*
+* @param  out        A character-output stream
+* @param  autoFlush  A boolean; if true, the <tt>println</tt>,
+*                    <tt>printf</tt>, or <tt>format</tt> methods will
+*                    flush the output buffer
+*/
+public PrintWriter(Writer out,
+		       boolean autoFlush) {
+	super(out);
+	this.out = out;
+	this.autoFlush = autoFlush;
+}
+/**
+* Creates a new PrintWriter, without automatic line flushing, from an
+* existing OutputStream.  This convenience constructor creates the
+* necessary intermediate OutputStreamWriter, which will convert characters
+* into bytes using the default character encoding.
+*
+* @param  out        An output stream
+*
+* @see java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
+*/
+public PrintWriter(OutputStream out) {
+	this(out, false);
+}
+/**
+* Creates a new PrintWriter from an existing OutputStream.  This
+* convenience constructor creates the necessary intermediate
+* OutputStreamWriter, which will convert characters into bytes using the
+* default character encoding.
+*
+* @param  out        An output stream
+* @param  autoFlush  A boolean; if true, the <tt>println</tt>,
+*                    <tt>printf</tt>, or <tt>format</tt> methods will
+*                    flush the output buffer
+*
+* @see java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
+*/
+public PrintWriter(OutputStream out, boolean autoFlush) {
+	this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);
+	// save print stream for error propagation
+	if (out instanceof java.io.PrintStream) {
+	    psOut = (PrintStream) out;
+	}
+}
+/**
+* Creates a new PrintWriter, without automatic line flushing, with the
+* specified file name.  This convenience constructor creates the necessary
+* intermediate {@link java.io.OutputStreamWriter OutputStreamWriter},
+* which will encode characters using the {@linkplain
+* java.nio.charset.Charset#defaultCharset() default charset} for this
+* instance of the Java virtual machine.
+*
+* @param  fileName
+*         The name of the file to use as the destination of this writer.
+*         If the file exists then it will be truncated to zero size;
+*         otherwise, a new file will be created.  The output will be
+*         written to the file and is buffered.
+*
+* @throws  FileNotFoundException
+*          If the given string does not denote an existing, writable
+*          regular file and a new regular file of that name cannot be
+*          created, or if some other error occurs while opening or
+*          creating the file
+*
+* @throws  SecurityException
+*          If a security manager is present and {@link
+*          SecurityManager#checkWrite checkWrite(fileName)} denies write
+*          access to the file
+*
+* @since  1.5
+*/
+public PrintWriter(String fileName) throws FileNotFoundException {
+	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
+	     false);
+}
+/**
+* Creates a new PrintWriter, without automatic line flushing, with the
+* specified file name and charset.  This convenience constructor creates
+* the necessary intermediate {@link java.io.OutputStreamWriter
+* OutputStreamWriter}, which will encode characters using the provided
+* charset.
+*
+* @param  fileName
+*         The name of the file to use as the destination of this writer.
+*         If the file exists then it will be truncated to zero size;
+*         otherwise, a new file will be created.  The output will be
+*         written to the file and is buffered.
+*
+* @param  csn
+*         The name of a supported {@linkplain java.nio.charset.Charset
+*         charset}
+*
+* @throws  FileNotFoundException
+*          If the given string does not denote an existing, writable
+*          regular file and a new regular file of that name cannot be
+*          created, or if some other error occurs while opening or
+*          creating the file
+*
+* @throws  SecurityException
+*          If a security manager is present and {@link
+*          SecurityManager#checkWrite checkWrite(fileName)} denies write
+*          access to the file
+*
+* @throws  UnsupportedEncodingException
+*          If the named charset is not supported
+*
+* @since  1.5
+*/
+public PrintWriter(String fileName, String csn)
+	throws FileNotFoundException, UnsupportedEncodingException
+{
+	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), csn)),
+	     false);
+}
+/**
+* Creates a new PrintWriter, without automatic line flushing, with the
+* specified file.  This convenience constructor creates the necessary
+* intermediate {@link java.io.OutputStreamWriter OutputStreamWriter},
+* which will encode characters using the {@linkplain
+* java.nio.charset.Charset#defaultCharset() default charset} for this
+* instance of the Java virtual machine.
+*
+* @param  file
+*         The file to use as the destination of this writer.  If the file
+*         exists then it will be truncated to zero size; otherwise, a new
+*         file will be created.  The output will be written to the file
+*         and is buffered.
+*
+* @throws  FileNotFoundException
+*          If the given file object does not denote an existing, writable
+*          regular file and a new regular file of that name cannot be
+*          created, or if some other error occurs while opening or
+*          creating the file
+*
+* @throws  SecurityException
+*          If a security manager is present and {@link
+*          SecurityManager#checkWrite checkWrite(file.getPath())}
+*          denies write access to the file
+*
+* @since  1.5
+*/
+public PrintWriter(File file) throws FileNotFoundException {
+	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
+	     false);
+}
+/**
+* Creates a new PrintWriter, without automatic line flushing, with the
+* specified file and charset.  This convenience constructor creates the
+* necessary intermediate {@link java.io.OutputStreamWriter
+* OutputStreamWriter}, which will encode characters using the provided
+* charset.
+*
+* @param  file
+*         The file to use as the destination of this writer.  If the file
+*         exists then it will be truncated to zero size; otherwise, a new
+*         file will be created.  The output will be written to the file
+*         and is buffered.
+*
+* @param  csn
+*         The name of a supported {@linkplain java.nio.charset.Charset
+*         charset}
+*
+* @throws  FileNotFoundException
+*          If the given file object does not denote an existing, writable
+*          regular file and a new regular file of that name cannot be
+*          created, or if some other error occurs while opening or
+*          creating the file
+*
+* @throws  SecurityException
+*          If a security manager is present and {@link
+*          SecurityManager#checkWrite checkWrite(file.getPath())}
+*          denies write access to the file
+*
+* @throws  UnsupportedEncodingException
+*          If the named charset is not supported
+*
+* @since  1.5
+*/
+public PrintWriter(File file, String csn)
+	throws FileNotFoundException, UnsupportedEncodingException
+{
+	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), csn)),
+	     false);
+}
+/** Checks to make sure that the stream has not been closed */
+private void ensureOpen() throws IOException {
+	if (out == null)
+	    throw new IOException("Stream closed");
+}
+/**
+* Flushes the stream.
+* @see #checkError()
+*/
+public void flush() {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		out.flush();
+	    }
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/**
+* Closes the stream and releases any system resources associated
+* with it. Closing a previously closed stream has no effect.
+*
+* @see #checkError()
+*/
+public void close() {
+	try {
+	    synchronized (lock) {
+		if (out == null)
+		    return;
+		out.close();
+		out = null;
+	    }
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/**
+* Flushes the stream if it's not closed and checks its error state.
+*
+* @return <code>true</code> if the print stream has encountered an error,
+* 		either on the underlying output stream or during a format
+*		conversion.
+*/
+public boolean checkError() {
+	if (out != null) {
+	    flush();
+	}
+	if (out instanceof java.io.PrintWriter) {
+	    PrintWriter pw = (PrintWriter) out;
+	    return pw.checkError();
+	} else if (psOut != null) {
+	    return psOut.checkError();
+	}
+	return trouble;
+}
+/**
+* Indicates that an error has occurred.
+*
+* <p> This method will cause subsequent invocations of {@link
+* #checkError()} to return <tt>true</tt> until {@link
+* #clearError()} is invoked.
+*/
+protected void setError() {
+	trouble = true;
+}
+/**
+* Clears the error state of this stream.
+*
+* <p> This method will cause subsequent invocations of {@link
+* #checkError()} to return <tt>false</tt> until another write
+* operation fails and invokes {@link #setError()}.
+*
+* @since 1.6
+*/
+protected void clearError() {
+trouble = false;
+}
+/*
+* Exception-catching, synchronized output operations,
+* which also implement the write() methods of Writer
+*/
+/**
+* Writes a single character.
+* @param c int specifying a character to be written.
+*/
+public void write(int c) {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		out.write(c);
+	    }
+	}
+	catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/**
+* Writes A Portion of an array of characters.
+* @param buf Array of characters
+* @param off Offset from which to start writing characters
+* @param len Number of characters to write
+*/
+public void write(char buf[], int off, int len) {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		out.write(buf, off, len);
+	    }
+	}
+	catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/**
+* Writes an array of characters.  This method cannot be inherited from the
+* Writer class because it must suppress I/O exceptions.
+* @param buf Array of characters to be written
+*/
+public void write(char buf[]) {
+	write(buf, 0, buf.length);
+}
+/**
+* Writes a portion of a string.
+* @param s A String
+* @param off Offset from which to start writing characters
+* @param len Number of characters to write
+*/
+public void write(String s, int off, int len) {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		out.write(s, off, len);
+	    }
+	}
+	catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/**
+* Writes a string.  This method cannot be inherited from the Writer class
+* because it must suppress I/O exceptions.
+* @param s String to be written
+*/
+public void write(String s) {
+	write(s, 0, s.length());
+}
+private void newLine() {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		out.write(lineSeparator);
+		if (autoFlush)
+		    out.flush();
+	    }
+	}
+	catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	}
+	catch (IOException x) {
+	    trouble = true;
+	}
+}
+/* Methods that do not terminate lines */
+/**
+* Prints a boolean value.  The string produced by <code>{@link
+* java.lang.String#valueOf(boolean)}</code> is translated into bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link
+* #write(int)}</code> method.
+*
+* @param      b   The <code>boolean</code> to be printed
+*/
+public void print(boolean b) {
+	write(b ? "true" : "false");
+}
+/**
+* Prints a character.  The character is translated into one or more bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link
+* #write(int)}</code> method.
+*
+* @param      c   The <code>char</code> to be printed
+*/
+public void print(char c) {
+	write(c);
+}
+/**
+* Prints an integer.  The string produced by <code>{@link
+* java.lang.String#valueOf(int)}</code> is translated into bytes according
+* to the platform's default character encoding, and these bytes are
+* written in exactly the manner of the <code>{@link #write(int)}</code>
+* method.
+*
+* @param      i   The <code>int</code> to be printed
+* @see        java.lang.Integer#toString(int)
+*/
+public void print(int i) {
+	write(String.valueOf(i));
+}
+/**
+* Prints a long integer.  The string produced by <code>{@link
+* java.lang.String#valueOf(long)}</code> is translated into bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link #write(int)}</code>
+* method.
+*
+* @param      l   The <code>long</code> to be printed
+* @see        java.lang.Long#toString(long)
+*/
+public void print(long l) {
+	write(String.valueOf(l));
+}
+/**
+* Prints a floating-point number.  The string produced by <code>{@link
+* java.lang.String#valueOf(float)}</code> is translated into bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link #write(int)}</code>
+* method.
+*
+* @param      f   The <code>float</code> to be printed
+* @see        java.lang.Float#toString(float)
+*/
+public void print(float f) {
+	write(String.valueOf(f));
+}
+/**
+* Prints a double-precision floating-point number.  The string produced by
+* <code>{@link java.lang.String#valueOf(double)}</code> is translated into
+* bytes according to the platform's default character encoding, and these
+* bytes are written in exactly the manner of the <code>{@link
+* #write(int)}</code> method.
+*
+* @param      d   The <code>double</code> to be printed
+* @see        java.lang.Double#toString(double)
+*/
+public void print(double d) {
+	write(String.valueOf(d));
+}
+/**
+* Prints an array of characters.  The characters are converted into bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link #write(int)}</code>
+* method.
+*
+* @param      s   The array of chars to be printed
+*
+* @throws  NullPointerException  If <code>s</code> is <code>null</code>
+*/
+public void print(char s[]) {
+	write(s);
+}
+/**
+* Prints a string.  If the argument is <code>null</code> then the string
+* <code>"null"</code> is printed.  Otherwise, the string's characters are
+* converted into bytes according to the platform's default character
+* encoding, and these bytes are written in exactly the manner of the
+* <code>{@link #write(int)}</code> method.
+*
+* @param      s   The <code>String</code> to be printed
+*/
+public void print(String s) {
+	if (s == null) {
+	    s = "null";
+	}
+	write(s);
+}
+/**
+* Prints an object.  The string produced by the <code>{@link
+* java.lang.String#valueOf(Object)}</code> method is translated into bytes
+* according to the platform's default character encoding, and these bytes
+* are written in exactly the manner of the <code>{@link #write(int)}</code>
+* method.
+*
+* @param      obj   The <code>Object</code> to be printed
+* @see        java.lang.Object#toString()
+*/
+public void print(Object obj) {
+	write(String.valueOf(obj));
+}
+/* Methods that do terminate lines */
+/**
+* Terminates the current line by writing the line separator string.  The
+* line separator string is defined by the system property
+* <code>line.separator</code>, and is not necessarily a single newline
+* character (<code>'\n'</code>).
+*/
+public void println() {
+	newLine();
+}
+/**
+* Prints a boolean value and then terminates the line.  This method behaves
+* as though it invokes <code>{@link #print(boolean)}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x the <code>boolean</code> value to be printed
+*/
+public void println(boolean x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints a character and then terminates the line.  This method behaves as
+* though it invokes <code>{@link #print(char)}</code> and then <code>{@link
+* #println()}</code>.
+*
+* @param x the <code>char</code> value to be printed
+*/
+public void println(char x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints an integer and then terminates the line.  This method behaves as
+* though it invokes <code>{@link #print(int)}</code> and then <code>{@link
+* #println()}</code>.
+*
+* @param x the <code>int</code> value to be printed
+*/
+public void println(int x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints a long integer and then terminates the line.  This method behaves
+* as though it invokes <code>{@link #print(long)}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x the <code>long</code> value to be printed
+*/
+public void println(long x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints a floating-point number and then terminates the line.  This method
+* behaves as though it invokes <code>{@link #print(float)}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x the <code>float</code> value to be printed
+*/
+public void println(float x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints a double-precision floating-point number and then terminates the
+* line.  This method behaves as though it invokes <code>{@link
+* #print(double)}</code> and then <code>{@link #println()}</code>.
+*
+* @param x the <code>double</code> value to be printed
+*/
+public void println(double x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints an array of characters and then terminates the line.  This method
+* behaves as though it invokes <code>{@link #print(char[])}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x the array of <code>char</code> values to be printed
+*/
+public void println(char x[]) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints a String and then terminates the line.  This method behaves as
+* though it invokes <code>{@link #print(String)}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x the <code>String</code> value to be printed
+*/
+public void println(String x) {
+	synchronized (lock) {
+	    print(x);
+	    println();
+	}
+}
+/**
+* Prints an Object and then terminates the line.  This method calls
+* at first String.valueOf(x) to get the printed object's string value,
+* then behaves as
+* though it invokes <code>{@link #print(String)}</code> and then
+* <code>{@link #println()}</code>.
+*
+* @param x  The <code>Object</code> to be printed.
+*/
+public void println(Object x) {
+	String s = String.valueOf(x);
+	synchronized (lock) {
+	    print(s);
+	    println();
+	}
+}
+/**
+* A convenience method to write a formatted string to this writer using
+* the specified format string and arguments.  If automatic flushing is
+* enabled, calls to this method will flush the output buffer.
+*
+* <p> An invocation of this method of the form <tt>out.printf(format,
+* args)</tt> behaves in exactly the same way as the invocation
+*
+* <pre>
+*     out.format(format, args) </pre>
+*
+* @param  format
+*         A format string as described in <a
+*         href="../util/Formatter.html#syntax">Format string syntax</a>.
+*
+* @param  args
+*         Arguments referenced by the format specifiers in the format
+*         string.  If there are more arguments than format specifiers, the
+*         extra arguments are ignored.  The number of arguments is
+*         variable and may be zero.  The maximum number of arguments is
+*         limited by the maximum dimension of a Java array as defined by
+*         the <a href="http://java.sun.com/docs/books/vmspec/">Java
+*         Virtual Machine Specification</a>.  The behaviour on a
+*         <tt>null</tt> argument depends on the <a
+*         href="../util/Formatter.html#syntax">conversion</a>.
+*
+* @throws  IllegalFormatException
+*          If a format string contains an illegal syntax, a format
+*          specifier that is incompatible with the given arguments,
+*          insufficient arguments given the format string, or other
+*          illegal conditions.  For specification of all possible
+*          formatting errors, see the <a
+*          href="../util/Formatter.html#detail">Details</a> section of the
+*          formatter class specification.
+*
+* @throws  NullPointerException
+*          If the <tt>format</tt> is <tt>null</tt>
+*
+* @return  This writer
+*
+* @since  1.5
+*/
+public PrintWriter printf(String format, Object ... args) {
+	return format(format, args);
+}
+/**
+* A convenience method to write a formatted string to this writer using
+* the specified format string and arguments.  If automatic flushing is
+* enabled, calls to this method will flush the output buffer.
+*
+* <p> An invocation of this method of the form <tt>out.printf(l, format,
+* args)</tt> behaves in exactly the same way as the invocation
+*
+* <pre>
+*     out.format(l, format, args) </pre>
+*
+* @param  l
+*         The {@linkplain java.util.Locale locale} to apply during
+*         formatting.  If <tt>l</tt> is <tt>null</tt> then no localization
+*         is applied.
+*
+* @param  format
+*         A format string as described in <a
+*         href="../util/Formatter.html#syntax">Format string syntax</a>.
+*
+* @param  args
+*         Arguments referenced by the format specifiers in the format
+*         string.  If there are more arguments than format specifiers, the
+*         extra arguments are ignored.  The number of arguments is
+*         variable and may be zero.  The maximum number of arguments is
+*         limited by the maximum dimension of a Java array as defined by
+*         the <a href="http://java.sun.com/docs/books/vmspec/">Java
+*         Virtual Machine Specification</a>.  The behaviour on a
+*         <tt>null</tt> argument depends on the <a
+*         href="../util/Formatter.html#syntax">conversion</a>.
+*
+* @throws  IllegalFormatException
+*          If a format string contains an illegal syntax, a format
+*          specifier that is incompatible with the given arguments,
+*          insufficient arguments given the format string, or other
+*          illegal conditions.  For specification of all possible
+*          formatting errors, see the <a
+*          href="../util/Formatter.html#detail">Details</a> section of the
+*          formatter class specification.
+*
+* @throws  NullPointerException
+*          If the <tt>format</tt> is <tt>null</tt>
+*
+* @return  This writer
+*
+* @since  1.5
+*/
+public PrintWriter printf(Locale l, String format, Object ... args) {
+	return format(l, format, args);
+}
+/**
+* Writes a formatted string to this writer using the specified format
+* string and arguments.  If automatic flushing is enabled, calls to this
+* method will flush the output buffer.
+*
+* <p> The locale always used is the one returned by {@link
+* java.util.Locale#getDefault() Locale.getDefault()}, regardless of any
+* previous invocations of other formatting methods on this object.
+*
+* @param  format
+*         A format string as described in <a
+*         href="../util/Formatter.html#syntax">Format string syntax</a>.
+*
+* @param  args
+*         Arguments referenced by the format specifiers in the format
+*         string.  If there are more arguments than format specifiers, the
+*         extra arguments are ignored.  The number of arguments is
+*         variable and may be zero.  The maximum number of arguments is
+*         limited by the maximum dimension of a Java array as defined by
+*         the <a href="http://java.sun.com/docs/books/vmspec/">Java
+*         Virtual Machine Specification</a>.  The behaviour on a
+*         <tt>null</tt> argument depends on the <a
+*         href="../util/Formatter.html#syntax">conversion</a>.
+*
+* @throws  IllegalFormatException
+*          If a format string contains an illegal syntax, a format
+*          specifier that is incompatible with the given arguments,
+*          insufficient arguments given the format string, or other
+*          illegal conditions.  For specification of all possible
+*          formatting errors, see the <a
+*          href="../util/Formatter.html#detail">Details</a> section of the
+*          Formatter class specification.
+*
+* @throws  NullPointerException
+*          If the <tt>format</tt> is <tt>null</tt>
+*
+* @return  This writer
+*
+* @since  1.5
+*/
+public PrintWriter format(String format, Object ... args) {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		if ((formatter == null)
+		    || (formatter.locale() != Locale.getDefault()))
+		    formatter = new Formatter(this);
+		formatter.format(Locale.getDefault(), format, args);
+		if (autoFlush)
+		    out.flush();
+	    }
+	} catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	} catch (IOException x) {
+	    trouble = true;
+	}
+	return this;
+}
+/**
+* Writes a formatted string to this writer using the specified format
+* string and arguments.  If automatic flushing is enabled, calls to this
+* method will flush the output buffer.
+*
+* @param  l
+*         The {@linkplain java.util.Locale locale} to apply during
+*         formatting.  If <tt>l</tt> is <tt>null</tt> then no localization
+*         is applied.
+*
+* @param  format
+*         A format string as described in <a
+*         href="../util/Formatter.html#syntax">Format string syntax</a>.
+*
+* @param  args
+*         Arguments referenced by the format specifiers in the format
+*         string.  If there are more arguments than format specifiers, the
+*         extra arguments are ignored.  The number of arguments is
+*         variable and may be zero.  The maximum number of arguments is
+*         limited by the maximum dimension of a Java array as defined by
+*         the <a href="http://java.sun.com/docs/books/vmspec/">Java
+*         Virtual Machine Specification</a>.  The behaviour on a
+*         <tt>null</tt> argument depends on the <a
+*         href="../util/Formatter.html#syntax">conversion</a>.
+*
+* @throws  IllegalFormatException
+*          If a format string contains an illegal syntax, a format
+*          specifier that is incompatible with the given arguments,
+*          insufficient arguments given the format string, or other
+*          illegal conditions.  For specification of all possible
+*          formatting errors, see the <a
+*          href="../util/Formatter.html#detail">Details</a> section of the
+*          formatter class specification.
+*
+* @throws  NullPointerException
+*          If the <tt>format</tt> is <tt>null</tt>
+*
+* @return  This writer
+*
+* @since  1.5
+*/
+public PrintWriter format(Locale l, String format, Object ... args) {
+	try {
+	    synchronized (lock) {
+		ensureOpen();
+		if ((formatter == null) || (formatter.locale() != l))
+		    formatter = new Formatter(this, l);
+		formatter.format(l, format, args);
+		if (autoFlush)
+		    out.flush();
+	    }
+	} catch (InterruptedIOException x) {
+	    Thread.currentThread().interrupt();
+	} catch (IOException x) {
+	    trouble = true;
+	}
+	return this;
+}
+/**
+* Appends the specified character sequence to this writer.
+*
+* <p> An invocation of this method of the form <tt>out.append(csq)</tt>
+* behaves in exactly the same way as the invocation
+*
+* <pre>
+*     out.write(csq.toString()) </pre>
+*
+* <p> Depending on the specification of <tt>toString</tt> for the
+* character sequence <tt>csq</tt>, the entire sequence may not be
+* appended. For instance, invoking the <tt>toString</tt> method of a
+* character buffer will return a subsequence whose content depends upon
+* the buffer's position and limit.
+*
+* @param  csq
+*         The character sequence to append.  If <tt>csq</tt> is
+*         <tt>null</tt>, then the four characters <tt>"null"</tt> are
+*         appended to this writer.
+*
+* @return  This writer
+*
+* @since  1.5
+*/
+public PrintWriter append(CharSequence csq) {
+	if (csq == null)
+	    write("null");
+	else
+	    write(csq.toString());
+	return this;
+}
+/**
+* Appends a subsequence of the specified character sequence to this writer.
+*
+* <p> An invocation of this method of the form <tt>out.append(csq, start,
+* end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
+* exactly the same way as the invocation
+*
+* <pre>
+*     out.write(csq.subSequence(start, end).toString()) </pre>
+*
+* @param  csq
+*         The character sequence from which a subsequence will be
+*         appended.  If <tt>csq</tt> is <tt>null</tt>, then characters
+*         will be appended as if <tt>csq</tt> contained the four
+*         characters <tt>"null"</tt>.
+*
+* @param  start
+*         The index of the first character in the subsequence
+*
+* @param  end
+*         The index of the character following the last character in the
+*         subsequence
+*
+* @return  This writer
+*
+* @throws  IndexOutOfBoundsException
+*          If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
+*          is greater than <tt>end</tt>, or <tt>end</tt> is greater than
+*          <tt>csq.length()</tt>
+*
+* @since  1.5
+*/
+public PrintWriter append(CharSequence csq, int start, int end) {
+	CharSequence cs = (csq == null ? "null" : csq);
+	write(cs.subSequence(start, end).toString());
+	return this;
+}
+/**
+* Appends the specified character to this writer.
+*
+* <p> An invocation of this method of the form <tt>out.append(c)</tt>
+* behaves in exactly the same way as the invocation
+*
+* <pre>
+*     out.write(c) </pre>
+*
+* @param  c
+*         The 16-bit character to append
+*
+* @return  This writer
+*
+* @since 1.5
+*/
+public PrintWriter append(char c) {
+	write(c);
+	return this;
+}
+}

Mercurial Hosting > nabble

comparison src/nabble/naml/compiler/PrintWriter.java @ 0:7ecd1a4ef557