/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package tugas.pkg1;

import
import
import
import

java.io.*;
java.util.IllegalFormatException;
java.util.regex.Matcher;
java.util.regex.Pattern;

import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
/**
* TextIO provides a set of static methods for reading and writing text. By def
ault, it reads
* from standard input and writes to standard output, but it is possible to redi
rect the input
* and output to files or to other input and output streams. When the standard
input and output
* streams are being used, the input methods will not produce an error; instead,
the user is
* repeatedly prompted for input until a legal input is entered. (If standard i
nput has been
* changed externally, as by file redirection on the command line, this is not a
reasonable
* behavior; to handle this case, TextIO will give up after 10 consecutive illeg
al inputs and
* will throw an IllegalArgumentException.) For the most part, any other
* error will be translated into an IllegalArguementException.
* <p>For writing to standard output, the output methods in this class pretty mu
ch
* duplicate the functionality of System.out, and System.out can be used interch
angeably with them.
* <p>This class does not use optimal Java programming practices. It is designe
d specifically to be easily
* usable even by a beginning programmer who has not yet learned about objects a
nd exceptions. Therefore,
* everything is in a single source file that compiles into a single class file,
all the methods are
* static methods, and none of the methods throw exceptions that would require t
ry...catch statements.
* Also for this reason, all exceptions are converted into IllegalArgumentExcept
ions, even when this
* exception type doesn't really make sense.
* <p>This class requires Java 5.0 or higher. (A previous version of TextIO requ
ired only Java 1.1;
* this version should work with any source code that used the previous version,
but it has some new
* features, including the type of formatted output that was introduced in Java
5 and the ability to
* use files and streams.)
*/
public class TextIO {

/* Modified November 2007 to empty the TextIO input buffer when switching fr
om one
* input source to another. This fixes a bug that allows input from the prev
ious input
* source to be read after the new source has been selected.
*/
/**
* The value returned by the peek() method when the input is at end-of-file.
* (The value of this constant is (char)0xFFFF.)
*/
public final static char EOF = (char)0xFFFF;
/**
* The
* The
*/
public
() when at

value returned by the peek() method when the input is at end-of-line.

value of this constant is the character '\n'.
final static char EOLN = '\n';
end-of-line.

// The value returned by peek

/**
* After this method is called, input will be read from standard input (as i
t
* is in the default state). If a file or stream was previously the input s
ource, that file
* or stream is closed.
*/
public static void readStandardInput() {
if (readingStandardInput)
return;
try {
in.close();
}
catch (Exception e) {
}
emptyBuffer(); // Added November 2007
in = standardInput;
inputFileName = null;
readingStandardInput = true;
inputErrorCount = 0;
}
/**
* After this method is called, input will be read from inputStream, provide
d it
* is non-null. If inputStream is null, then this method has the same effec
t
* as calling readStandardInput(); that is, future input will come from the
* standard input stream.
*/
public static void readStream(InputStream inputStream) {
if (inputStream == null)
readStandardInput();
else
readStream(new InputStreamReader(inputStream));
}
/**
* After this method is called, input will be read from inputStream, provide

d it
* is non-null. If inputStream is null, then this method has the same effec
t
* as calling readStandardInput(); that is, future input will come from the
* standard input stream.
*/
public static void readStream(Reader inputStream) {
if (inputStream == null)
readStandardInput();
else {
if ( inputStream instanceof BufferedReader)
in = (BufferedReader)inputStream;
else
in = new BufferedReader(inputStream);
emptyBuffer(); // Added November 2007
inputFileName = null;
readingStandardInput = false;
inputErrorCount = 0;
}
}
/**
* Opens a file with a specified name for input. If the file name is null,
this has
* the same effect as calling readStandardInput(); that is, input will be re
ad from standard
* input. If an
* error occurs while trying to open the file, an exception of type IllegalA
rgumentException
* is thrown, and the input source is not changed. If the file is opened
* successfully, then after this method is called, all of the input routines
will read
* from the file, instead of from standard input.
*/
public static void readFile(String fileName) {
if (fileName == null) // Go back to reading standard input
readStandardInput();
else {
BufferedReader newin;
try {
newin = new BufferedReader( new FileReader(fileName) );
}
catch (Exception e) {
throw new IllegalArgumentException("Can't open file \"" + fileNa
me + "\" for input.\n"
+ "(Error :" + e + ")");
}
if (! readingStandardInput) { // close current input stream
try {
in.close();
}
catch (Exception e) {
}
}
emptyBuffer(); // Added November 2007
in = newin;
readingStandardInput = false;
inputErrorCount = 0;
inputFileName = fileName;
}

}
/**
* Puts a GUI file-selection dialog box on the screen in which the user can
select
* an input file. If the user cancels the dialog instead of selecting a fil
e, it is
* not considered an error, but the return value of the subroutine is false.
* If the user does select a file, but there is an error while trying to ope
n the
* file, then an exception of type IllegalArgumentException is thrown. Fina
lly, if
* the user selects a file and it is successfully opened, then the return va
lue of the
* subroutine is true, and the input routines will read from the file, inst
ead of
* from standard input. If the user cancels, or if any error occurs, then
the
* previous input source is not changed.
* <p>NOTE: Calling this method starts a GUI user interface thread, which ca
n continue
* to run even if the thread that runs the main program ends. If you use th
is method
* in a non-GUI program, it might be necessary to call System.exit(0) at the
end of the main()
* routine to shut down the Java virtual machine completely.
*/
public static boolean readUserSelectedFile() {
if (fileDialog == null)
fileDialog = new JFileChooser();
fileDialog.setDialogTitle("Select File for Input");
int option = fileDialog.showOpenDialog(null);
if (option != JFileChooser.APPROVE_OPTION)
return false;
File selectedFile = fileDialog.getSelectedFile();
BufferedReader newin;
try {
newin = new BufferedReader( new FileReader(selectedFile) );
}
catch (Exception e) {
throw new IllegalArgumentException("Can't open file \"" + selectedFi
le.getName() + "\" for input.\n"
+ "(Error :" + e + ")");
}
if (!readingStandardInput) { // close current file
try {
in.close();
}
catch (Exception e) {
}
}
emptyBuffer(); // Added November 2007
in = newin;
inputFileName = selectedFile.getName();
readingStandardInput = false;
inputErrorCount = 0;
return true;
}
/**

* After this method is called, output will be written to standard output (a

s it
* is in the default state). If a file or stream was previously open for ou
tput, it
* will be closed.
*/
public static void writeStandardOutput() {
if (writingStandardOutput)
return;
try {
out.close();
}
catch (Exception e) {
}
outputFileName = null;
outputErrorCount = 0;
out = standardOutput;
writingStandardOutput = true;
}
/**
* After this method is called, output will be sent to outputStream, provide
d it
* is non-null. If outputStream is null, then this method has the same effe
ct
* as calling writeStandardOutput(); that is, future output will be sent to
the
* standard output stream.
*/
public static void writeStream(OutputStream outputStream) {
if (outputStream == null)
writeStandardOutput();
else
writeStream(new PrintWriter(outputStream));
}
/**
* After this method is called, output will be sent to outputStream, provide
d it
* is non-null. If outputStream is null, then this method has the same effe
ct
* as calling writeStandardOutput(); that is, future output will be sent to
the
* standard output stream.
*/
public static void writeStream(PrintWriter outputStream) {
if (outputStream == null)
writeStandardOutput();
else {
out = outputStream;
outputFileName = null;
outputErrorCount = 0;
writingStandardOutput = false;
}
}
/**
* Opens a file with a specified name for output. If the file name is null,

this has
* the same effect as calling writeStandardOutput(); that is, output will be
sent to standard
* output. If an
* error occurs while trying to open the file, an exception of type IllegalA
rgumentException
* is thrown. If the file is opened successfully, then after this method is
called,
* all of the output routines will write to the file, instead of to standar
d output.
* If an error occurs, the output destination is not changed.
* <p>NOTE: Calling this method starts a GUI user interface thread, which ca
n continue
* to run even if the thread that runs the main program ends. If you use th
is method
* in a non-GUI program, it might be necessary to call System.exit(0) at the
end of the main()
* routine to shut down the Java virtual machine completely.
*/
public static void writeFile(String fileName) {
if (fileName == null) // Go back to reading standard output
writeStandardOutput();
else {
PrintWriter newout;
try {
newout = new PrintWriter(new FileWriter(fileName));
}
catch (Exception e) {
throw new IllegalArgumentException("Can't open file \"" + fileNa
me + "\" for output.\n"
+ "(Error :" + e + ")");
}
if (!writingStandardOutput) {
try {
out.close();
}
catch (Exception e) {
}
}
out = newout;
writingStandardOutput = false;
outputFileName = fileName;
outputErrorCount = 0;
}
}
/**
* Puts a GUI file-selection dialog box on the screen in which the user can
select
* an output file. If the user cancels the dialog instead of selecting a fi
le, it is
* not considered an error, but the return value of the subroutine is false.
* If the user does select a file, but there is an error while trying to ope
n the
* file, then an exception of type IllegalArgumentException is thrown. Fina
lly, if
* the user selects a file and it is successfully opened, then the return va
lue of the
* subroutine is true, and the output routines will write to the file, inst
ead of

* to standard output. If the user cancels, or if an error occurs, then the

current
* output destination is not changed.
*/
public static boolean writeUserSelectedFile() {
if (fileDialog == null)
fileDialog = new JFileChooser();
fileDialog.setDialogTitle("Select File for Output");
File selectedFile;
while (true) {
int option = fileDialog.showSaveDialog(null);
if (option != JFileChooser.APPROVE_OPTION)
return false; // user canceled
selectedFile = fileDialog.getSelectedFile();
if (selectedFile.exists()) {
int response = JOptionPane.showConfirmDialog(null,
"The file \"" + selectedFile.getName() + "\" already exi
sts. Do you want to replace it?",
"Replace existing file?",
JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
if (response == JOptionPane.YES_OPTION)
break;
}
else {
break;
}
}
PrintWriter newout;
try {
newout = new PrintWriter(new FileWriter(selectedFile));
}
catch (Exception e) {
throw new IllegalArgumentException("Can't open file \"" + selectedFi
le.getName() + "\" for output.\n"
+ "(Error :" + e + ")");
}
if (!writingStandardOutput) {
try {
out.close();
}
catch (Exception e) {
}
}
out = newout;
writingStandardOutput = false;
outputFileName = selectedFile.getName();
outputErrorCount = 0;
return true;
}
/**
* If TextIO is currently reading from a file, then the return value is the
name of the file.
* If the class is reading from standard input or from a stream, then the re
turn value is null.
*/
public static String getInputFileName() {
return inputFileName;
}

/**
* If TextIO is currently writing to a file, then the return value is the na
me of the file.
* If the class is writing to standard output or to a stream, then the retur
n value is null.
*/
public static String getOutputFileName() {
return outputFileName;
}
// *************************** Output Methods ******************************
***
/**
* Write a single value to the current output destination, using the default
format
* and no extra spaces. This method will handle any type of parameter, even
one
* whose type is one of the primitive types.
*/
public static void put(Object x) {
out.print(x);
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
/**
* Write a single value to the current output destination, using the default
format
* and outputting at least minChars characters (with extra spaces added befo
re the
* output value if necessary). This method will handle any type of paramete
r, even one
* whose type is one of the primitive types.
* @param x The value to be output, which can be of any type.
* @param minChars The minimum number of characters to use for the output.
If x requires fewer
* then this number of characters, then extra spaces are added to the front
of x to bring
* the total up to minChars. If minChars is less than or equal to zero, the
n x will be printed
* in the minimum number of spaces possible.
*/
public static void put(Object x, int minChars) {
if (minChars <= 0)
out.print(x);
else
out.printf("%" + minChars + "s", x);
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
/**
* This is equivalent to put(x), followed by an end-of-line.
*/

public static void putln(Object x) {

out.println(x);
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
/**
* This is equivalent to put(x,minChars), followed by an end-of-line.
*/
public static void putln(Object x, int minChars) {
put(x,minChars);
out.println();
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
/**
* Write an end-of-line character to the current output destination.
*/
public static void putln() {
out.println();
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
/**
* Writes formatted output values to the current output destination. This m
ethod has the
* same function as System.out.printf(); the details of formatted output are
not discussed
* here. The first parameter is a string that describes the format of the o
utput. There
* can be any number of additional parameters; these specify the values to b
e output and
* can be of any type. This method will throw an IllegalArgumentException i
f the
* format string is null or if the format string is illegal for the values t
hat are being
* output.
*/
public static void putf(String format, Object... items) {
if (format == null)
throw new IllegalArgumentException("Null format string in TextIO.put
f() method.");
try {
out.printf(format,items);
}
catch (IllegalFormatException e) {
throw new IllegalArgumentException("Illegal format string in TextIO.
putf() method.");
}
out.flush();
if (out.checkError())
outputError("Error while writing output.");
}
// *************************** Input Methods *******************************

**
/**
* Test whether the next character in the current input source is an end-ofline. Note that
* this method does NOT skip whitespace before testing for end-of-line -- if
you want to do
* that, call skipBlanks() first.
*/
public static boolean eoln() {
return peek() == '\n';
}
/**
* Test whether the next character in the current input source is an end-offile. Note that
* this method does NOT skip whitespace before testing for end-of-line -- if
you want to do
* that, call skipBlanks() or skipWhitespace() first.
*/
public static boolean eof() {
return peek() == EOF;
}
/**
* Reads the next character from the current input source. The character ca
n be a whitespace
* character; compare this to the getChar() method, which skips over whitesp
ace and returns the
* next non-whitespace character. An end-of-line is always returned as the
character '\n', even
* when the actual end-of-line in the input source is something else, such a
s '\r' or "\r\n".
* This method will throw an IllegalArgumentException if the input is at end
-of-file (which will
* not ordinarily happen if reading from standard input).
*/
public static char getAnyChar() {
return readChar();
}
/**
* Returns the next character in the current input source, without actually
removing that
* character from the input. The character can be a whitespace character an
d can be the
* end-of-file character (specified by the constant TextIO.EOF).An end-of-li
ne is always returned
* as the character '\n', even when the actual end-of-line in the input sour
ce is something else,
* such as '\r' or "\r\n". This method never causes an error.
*/
public static char peek() {
return lookChar();
}
/**
* Skips over any whitespace characters, except for end-of-lines. After thi
s method is called,
* the next input character is either an end-of-line, an end-of-file, or a n

on-whitespace character.
* This method never causes an error. (Ordinarily, end-of-file is not possi
ble when reading from
* standard input.)
*/
public static void skipBlanks() {
char ch=lookChar();
while (ch != EOF && ch != '\n' && Character.isWhitespace(ch)) {
readChar();
ch = lookChar();
}
}
/**
* Skips over any whitespace characters, including for end-of-lines. After
this method is called,
* the next input character is either an end-of-file or a non-whitespace cha
racter.
* This method never causes an error. (Ordinarily, end-of-file is not possib
le when reading from
* standard input.)
*/
private static void skipWhitespace() {
char ch=lookChar();
while (ch != EOF && Character.isWhitespace(ch)) {
readChar();
if (ch == '\n' && readingStandardInput && writingStandardOutput) {
out.print("? ");
out.flush();
}
ch = lookChar();
}
}
/**
* Skips whitespace characters and then reads a value of type byte from inpu
t, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static byte getlnByte() {
byte x=getByte();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type short from inp
ut, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/

public static short getlnShort() {

short x=getShort();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type int from input
, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static int getlnInt() {
int x=getInt();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type long from inpu
t, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static long getlnLong() {
long x=getLong();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type float from inp
ut, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static float getlnFloat() {
float x=getFloat();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type double from in
put, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for

input until a legal value

* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static double getlnDouble() {
double x=getDouble();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type char from inpu
t, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). Note that the value
* that is returned will be a non-whitespace character; compare this with th
e getAnyChar() method.
* When using standard IO, this will not produce an error. In other cases,
an error can occur if
* an end-of-file is encountered.
*/
public static char getlnChar() {
char x=getChar();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads a value of type boolean from i
nput, discarding the rest of
* the current line of input (including the next end-of-line character, if a
ny). When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
* <p>Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no
, n, and 0; letters can be
* either upper case or lower case. One "word" of input is read, using the g
etWord() method, and it
* must be one of these; note that the "word" must be terminated by a white
space character (or end-of-file).
*/
public static boolean getlnBoolean() {
boolean x=getBoolean();
emptyBuffer();
return x;
}
/**
* Skips whitespace characters and then reads one "word" from input, discard
ing the rest of
* the current line of input (including the next end-of-line character, if a
ny). A word is defined as
* a sequence of non-whitespace characters (not just letters!). When using
standard IO,
* this will not produce an error. In other cases, an IllegalArgumentExcept
ion will be thrown
* if an end-of-file is encountered.
*/

public static String getlnWord() {

String x=getWord();
emptyBuffer();
return x;
}
/**
* This is identical to getln().
*/
public static String getlnString() {
return getln();
}
/**
* Reads all the characters from the current input source, up to the next en
d-of-line. The end-of-line
* is read but is not included in the return value. Any other whitespace ch
aracters on the line are retained,
* even if they occur at the start of input. The return value will be an em
pty string if there are
* no characters before the end-of-line. When using standard IO, this will
not produce an error.
* In other cases, an IllegalArgumentException will be thrown if an end-of-f
ile is encountered.
*/
public static String getln() {
StringBuffer s = new StringBuffer(100);
char ch = readChar();
while (ch != '\n') {
s.append(ch);
ch = readChar();
}
return s.toString();
}
/**
* Skips whitespace characters and then reads a value of type byte from inpu
t. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static byte getByte() {
return (byte)readInteger(-128L,127L);
}
/**
* Skips whitespace characters and then reads a value of type short from inp
ut. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static short getShort() {

return (short)readInteger(-32768L,32767L);
}
/**
* Skips whitespace characters and then reads a value of type int from input
. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static int getInt()
{
return (int)readInteger(Integer.MIN_VALUE, Integer.MAX_VALUE);
}
/**
* Skips whitespace characters and then reads a value of type long from inpu
t. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static long getLong() {
return readInteger(Long.MIN_VALUE, Long.MAX_VALUE);
}
/**
* Skips whitespace characters and then reads a single non-whitespace charac
ter from input. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error. In other cases, an IllegalArgumentExcept
ion will be thrown if an end-of-file
* is encountered.
*/
public static char getChar() {
skipWhitespace();
return readChar();
}
/**
* Skips whitespace characters and then reads a value of type float from inp
ut. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static float getFloat() {
float x = 0.0F;
while (true) {
String str = readRealString();
if (str == null) {

errorMessage("Floating point number not found.",

"Real number in the range " + (-Float.MAX_VALUE) + " to
" + Float.MAX_VALUE);
}
else {
try {
x = Float.parseFloat(str);
}
catch (NumberFormatException e) {
errorMessage("Illegal floating point input, " + str + ".",
"Real number in the range " + (-Float.MAX_VALUE) +
" to " + Float.MAX_VALUE);
continue;
}
if (Float.isInfinite(x)) {
errorMessage("Floating point input outside of legal range, "
+ str + ".",
"Real number in the range " + (-Float.MAX_VALUE) +
" to " + Float.MAX_VALUE);
continue;
}
break;
}
}
inputErrorCount = 0;
return x;
}
/**
* Skips whitespace characters and then reads a value of type double from in
put. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
*/
public static double getDouble() {
double x = 0.0;
while (true) {
String str = readRealString();
if (str == null) {
errorMessage("Floating point number not found.",
"Real number in the range " + (-Double.MAX_VALUE) + " to
" + Double.MAX_VALUE);
}
else {
try {
x = Double.parseDouble(str);
}
catch (NumberFormatException e) {
errorMessage("Illegal floating point input, " + str + ".",
"Real number in the range " + (-Double.MAX_VALUE) +
" to " + Double.MAX_VALUE);
continue;
}
if (Double.isInfinite(x)) {
errorMessage("Floating point input outside of legal range, "
+ str + ".",

"Real number in the range " + (-Double.MAX_VALUE) +

" to " + Double.MAX_VALUE);
continue;
}
break;
}
}
inputErrorCount = 0;
return x;
}
/**
* Skips whitespace characters and then reads one "word" from input. Any add
itional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. A word is defined as
* a sequence of non-whitespace characters (not just letters!). When using
standard IO,
* this will not produce an error. In other cases, an IllegalArgumentExcept
ion will be thrown
* if an end-of-file is encountered.
*/
public static String getWord() {
skipWhitespace();
StringBuffer str = new StringBuffer(50);
char ch = lookChar();
while (ch == EOF || !Character.isWhitespace(ch)) {
str.append(readChar());
ch = lookChar();
}
return str.toString();
}
/**
* Skips whitespace characters and then reads a value of type boolean from i
nput. Any additional characters on
* the current line of input are retained, and will be read by the next inpu
t operation. When using standard IO,
* this will not produce an error; the user will be prompted repeatedly for
input until a legal value
* is input. In other cases, an IllegalArgumentException will be thrown if
a legal value is not found.
* <p>Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no
, n, and 0; letters can be
* either upper case or lower case. One "word" of input is read, using the g
etWord() method, and it
* must be one of these; note that the "word" must be terminated by a white
space character (or end-of-file).
*/
public static boolean getBoolean() {
boolean ans = false;
while (true) {
String s = getWord();
if ( s.equalsIgnoreCase("true") || s.equalsIgnoreCase("t") ||
s.equalsIgnoreCase("yes") || s.equalsIgnoreCase("y") ||
s.equals("1") ) {
ans = true;
break;
}
else if ( s.equalsIgnoreCase("false") || s.equalsIgnoreCase("f") ||

s.equalsIgnoreCase("no") || s.equalsIgnoreCase("n") ||
s.equals("0") ) {
ans = false;
break;
}
else
errorMessage("Illegal boolean input value.",
"one of: true, false, t, f, yes, no, y, n, 0, or 1");
}
inputErrorCount = 0;
return ans;
}
// ***************** Everything beyond this point is private implementation
detail *******************
private static String inputFileName; // Name of file that is the current in
put source, or null if the source is not a file.
private static String outputFileName; // Name of file that is the current ou
tput destination, or null if the destination is not a file.
private static JFileChooser fileDialog; // Dialog used by readUserSelectedFi
le() and writeUserSelectedFile()
private final static BufferedReader standardInput = new BufferedReader(new I
nputStreamReader(System.in)); // wraps standard input stream
private final static PrintWriter standardOutput = new PrintWriter(System.out
); // wraps standard output stream
private static BufferedReader in = standardInput; // Stream that data is re
ad from; the current input source.
private static PrintWriter out = standardOutput; // Stream that data is wr
itten to; the current output destination.
private static boolean readingStandardInput = true;
private static boolean writingStandardOutput = true;
private static int
dard input; reset to 0
private static int
since it was selected

inputErrorCount; // Number of consecutive errors on stan

when a successful read occurs.
outputErrorCount; // Number of errors on standard output
as the output destination.

private static Matcher integerMatcher; // Used for reading integer numbers;

created from the integer Regex Pattern.
private static Matcher floatMatcher; // Used for reading floating point nu
mbers; created from the floatRegex Pattern.
private final static Pattern integerRegex = Pattern.compile("(\\+|-)?[0-9]+"
);
private final static Pattern floatRegex = Pattern.compile("(\\+|-)?(([0-9]+(
\\.[0-9]*)?)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?");
private static String buffer = null; // One line read from input.
private static int pos = 0;
// Position of next char in input line
that has not yet been processed.
private static String readRealString() {
g syntax of real numbers
skipWhitespace();
if (lookChar() == EOF)
return null;

// read chars from input followin

if (floatMatcher == null)
floatMatcher = floatRegex.matcher(buffer);
floatMatcher.region(pos,buffer.length());
if (floatMatcher.lookingAt()) {
String str = floatMatcher.group();
pos = floatMatcher.end();
return str;
}
else
return null;
}
private static String readIntegerString() { // read chars from input follow
ing syntax of integers
skipWhitespace();
if (lookChar() == EOF)
return null;
if (integerMatcher == null)
integerMatcher = integerRegex.matcher(buffer);
integerMatcher.region(pos,buffer.length());
if (integerMatcher.lookingAt()) {
String str = integerMatcher.group();
pos = integerMatcher.end();
return str;
}
else
return null;
}
private static long readInteger(long min, long max) { // read long integer,
limited to specified range
long x=0;
while (true) {
String s = readIntegerString();
if (s == null){
errorMessage("Integer value not found in input.",
"Integer in the range " + min + " to " + max);
}
else {
String str = s.toString();
try {
x = Long.parseLong(str);
}
catch (NumberFormatException e) {
errorMessage("Illegal integer input, " + str + ".",
"Integer in the range " + min + " to " + max);
continue;
}
if (x < min || x > max) {
errorMessage("Integer input outside of legal range, " + str
+ ".",
"Integer in the range " + min + " to " + max);
continue;
}
break;
}
}
inputErrorCount = 0;
return x;
}

private static void errorMessage(String message, String expecting) { // Rep

ort error on input.
if (readingStandardInput && writingStandardOutput) {
// inform user of error and force user to re-enter.
out.println();
out.print(" *** Error in input: " + message + "\n");
out.print(" *** Expecting: " + expecting + "\n");
out.print(" *** Discarding Input: ");
if (lookChar() == '\n')
out.print("(end-of-line)\n\n");
else {
while (lookChar() != '\n')
// Discard and echo remaining char
s on the current line of input.
out.print(readChar());
out.print("\n\n");
}
out.print("Please re-enter: ");
out.flush();
readChar(); // discard the end-of-line character
inputErrorCount++;
if (inputErrorCount >= 10)
throw new IllegalArgumentException("Too many input consecutive i
nput errors on standard input.");
}
else if (inputFileName != null)
throw new IllegalArgumentException("Error while reading from file \"
" + inputFileName + "\":\n"
+ message + "\nExpecting " + expecting);
else
throw new IllegalArgumentException("Error while reading from inptu s
tream:\n"
+ message + "\nExpecting " + expecting);
}
private static char lookChar() { // return next character from input
if (buffer == null || pos > buffer.length())
fillBuffer();
if (buffer == null)
return EOF;
else if (pos == buffer.length())
return '\n';
else
return buffer.charAt(pos);
}
private static char readChar() { // return and discard next character from
input
char ch = lookChar();
if (buffer == null) {
if (readingStandardInput)
throw new IllegalArgumentException("Attempt to read past end-offile in standard input???");
else
throw new IllegalArgumentException("Attempt to read past end-offile in file \"" + inputFileName + "\".");
}
pos++;
return ch;

}
private static void fillBuffer() {
// Wait for user to type a line and pr
ess return,
try {
buffer = in.readLine();
}
catch (Exception e) {
if (readingStandardInput)
throw new IllegalArgumentException("Error while reading standard
input???");
else if (inputFileName != null)
throw new IllegalArgumentException("Error while attempting to re
ad from file \"" + inputFileName + "\".");
else
throw new IllegalArgumentException("Errow while attempting to re
ad form an input stream.");
}
pos = 0;
floatMatcher = null;
integerMatcher = null;
}
private static void emptyBuffer() {
e of input
buffer = null;
}

// discard the rest of the current lin

private static void outputError(String message) { // Report an error on out

put.
if (writingStandardOutput) {
System.err.println("Error occurred in TextIO while writing to standa
rd output!!");
outputErrorCount++;
if (outputErrorCount >= 10) {
outputErrorCount = 0;
throw new IllegalArgumentException("Too many errors while writin
g to standard output.");
}
}
else if (outputFileName != null){
throw new IllegalArgumentException("Error occurred while writing to
file \""
+ outputFileName+ "\":\n " + message);
}
else {
throw new IllegalArgumentException("Error occurred while writing to
output stream:\n " + message);
}
}
static void putint(int age) {
throw new UnsupportedOperationException("Not supported yet."); //To chan
ge body of generated methods, choose Tools | Templates.
}
} // end of class TextIO