[java] Images in Java

    public Image generateImage() {        int rawHeight = 256;        int rawWidth = 256;        int[] myPixels = new int[rawWidth * rawHeight];        for (int y = 0; y < rawHeight; y++) {            for (int x = 0; x < rawWidth; x++) {                myPixels[y * rawWidth + x] = ((y ^ x) << 24) | ((y ^ x) << 16) | ((y ^ x) << 8);            }        }        return (this.createImage(new MemoryImageSource(rawWidth, rawHeight, myPixels, 0, rawWidth)));    }

int rawHeight = 256;int rawWidth = 256;int[] MyPixels = new int[rawWidth * rawHeight];for(int i = 0; i < rawWidth; i++){  for(int j = 0; j < rawHeight; j++) {    MyPixels[j * rawWidth + i] = MyPixels[j * rawWidth + i] + (i*j) + 100;  }}

int[] pixelData; // contains your pixels in a 1D arrayint width, height; // I assume these variables contain the image's width & height/* Create the buffered image instance */BufferedImage image =    new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);/* Set color data */image.setRGB(0, 0, width, height, pixelData, 0, width);/* Save it to file */try{    ImageIO.write( image, "PNG", new File("output.png") );}catch ( IOException e ){    // Something bad happened    System.out.println(e);}

import java.awt.image.*;public class App{    public static void main(String[] args)    {        // Produce image        BufferedImage image =            new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);                for ( int y = 0; y != image.getHeight(); ++y )        {            for ( int x = 0; x != image.getWidth(); ++x )            {                int t = (x & 0xFF);                int u = (y & 0xFF);                               int c = (255 << 24) | (t << 16) | (u << 8) | t;                               image.setRGB(x, y, c);            }        }                // Create new window that will draw the image to the screen        ImageWindow wnd = new ImageWindow(image);                wnd.setVisible(true);    }}

import java.awt.*;import javax.swing.*;public class ImageViewer extends JComponent{    public ImageViewer()    {            }        protected void paintComponent(Graphics g)    {        System.out.println("Painting");        if ( _image != null )        {            g.drawImage(_image, 0, 0, new DummyObserver());        }    }        public void setImage(Image image)    {        _image = image;        repaint();    }        private Image _image;            private static class DummyObserver implements ImageObserver    {        public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h)        {            return true;        }    }}

import java.awt.*;import javax.swing.*;public class ImageWindow extends JFrame{    public ImageWindow(Image image)    {        super("Image viewer");                _imageViewer = new ImageViewer();        getContentPane().add( _imageViewer );                _imageViewer.setImage(image);        setSize(300, 300);        setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );    }        private ImageViewer _imageViewer;}

import java.awt.image.*;public class App{    public static void main(String[] args)    {        BufferedImage image = paintImage();                ImageWindow wnd = new ImageWindow(image);        wnd.setVisible(true);    }        public static BufferedImage paintImage()    {        BufferedImage image =            new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);                int[] pixels = new int[256*256];                // Fill array with color values        for ( int x = 0; x != 256; ++x )        {            for ( int y = 0; y != 256; ++y )            {                pixels[256*y+x] = (0xFF << 24) | (x * y + 100);            }        }                // Write colors to image        image.setRGB(0, 0, 256, 256, pixels, 0, 256);                return image;    }    // r,g,b should be >= 0 and <= 255, otherwise    // you will get strange results    private static int makeRGB(int r, int g, int b)    {        return (0xFF << 24) | (r << 16) | (g << 8) | b;    }        // grayLevel should be >=0 and <255.    // 0 gives black, 255 white.    private static int makeGray(int grayLevel)    {        return makeRGB(grayLevel, grayLevel, grayLevel);    }}

import java.awt.image.*;public class App{    public static void main(String[] args)    {        BufferedImage image = paintImage();                ImageWindow wnd = new ImageWindow(image);        wnd.setVisible(true);    }        public static BufferedImage paintImage()    {        BufferedImage image =            new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);                int[] R, G, B;        /* Here you initialize R,G,B */        int[] pixels = new int[256*256];                // Fill array with color values        for ( int x = 0; x != 256; ++x )        {            for ( int y = 0; y != 256; ++y )            {                int i = 256*y+x;                pixels = makeRGB(R, G, B);            }        }                // Write colors to image        image.setRGB(0, 0, 256, 256, pixels, 0, 256);                return image;    }    // r,g,b should be >= 0 and <= 255, otherwise    // you will get strange results    private static int makeRGB(int r, int g, int b)    {        return (0xFF << 24) | (r << 16) | (g << 8) | b;    }        // grayLevel should be >=0 and <255.    // 0 gives black, 255 white.    private static int makeGray(int grayLevel)    {        return makeRGB(grayLevel, grayLevel, grayLevel);    }}

import java.io.*;import javax.swing.*;import java.util.*;import javax.imageio.*;import java.awt.*;import java.applet.Applet;import java.awt.event.*;import java.awt.image.*;import javax.swing.*;public class ft extends JFrame  {   public static void main(String[] args) {             new ft();   }      private JTextArea text;  // Holds the text that is displayed in the window.   demoframe Imagewindow;   public int index=0;   String textArray[];   int rawHeight =256 ;   int rawWidth = 256;  int [] myPixels = new int[rawWidth * rawHeight];   // double R[], G[], B[];       Image rawImage;         int XX = 256*256 ;        int[] R, G, B;                        public ft() {                            super(" Text Editor");      setJMenuBar(makeButtons());      text = new JTextArea("<<Insert text here>>",25,50);     // text = new JTextField(20);      text.setBackground(Color.white);      text.setMargin( new Insets(3,5,0,0) );      JScrollPane scroller = new JScrollPane(text);      setContentPane(scroller);      setDefaultCloseOperation(EXIT_ON_CLOSE);      pack();      setLocation(50,50);      show();            Imagewindow = new demoframe("Compressed Text Window");      Imagewindow.resize(500,500);              R = new int [XX];        G = new int [XX];        B = new int [XX];}      private JMenuBar makeButtons() {       ActionListener listener = new ActionListener() {                 public void actionPerformed(ActionEvent evt) {               String cmd = evt.getActionCommand();                               if (cmd.equals("CLEAR"))                  doNew();               if (cmd.equals("OPEN"))                  doOpen();               if (cmd.equals("SAVE"))                  doSave();               if (cmd.equals("COMPRESS TEXT"))               {  doCompress();               }                               if (cmd.equals("VIEW IMAGE"))                 {                      //hide();                   doViewImage();               }               if (cmd.equals("QUIT"))                  doQuit();            }         };               JButton ClearButton = new JButton("CLEAR");      ClearButton.setEnabled( true );      ClearButton.addActionListener(listener);            JButton OpenButton = new JButton("OPEN");      OpenButton.setEnabled( true );      OpenButton.addActionListener(listener);               JButton SaveButton = new JButton("SAVE");      SaveButton.setEnabled( true );      SaveButton.addActionListener(listener);            JButton QuitButton = new JButton("QUIT");      QuitButton.setEnabled( true );      QuitButton.addActionListener(listener);                 JButton CompressButton = new JButton("COMPRESS TEXT");      CompressButton.setEnabled( true );      CompressButton.addActionListener(listener);                 JButton HideImageButton = new JButton("VIEW IMAGE");      HideImageButton.setEnabled( true );      HideImageButton.addActionListener(listener);            JMenuBar bar = new JMenuBar();      bar.add(ClearButton);      bar.add(OpenButton);      bar.add(SaveButton);      bar.add(CompressButton);      bar.add(HideImageButton);      bar.add(QuitButton);            return bar;   }   private void doNew() {        text.setText("");   }   private void doSave() {      File file;         JFileChooser fd;       fd = new JFileChooser(new File("."));      fd.setDialogTitle("Save Text As...");      int action = fd.showSaveDialog(this);      if (action != JFileChooser.APPROVE_OPTION) {         return;      }      file = fd.getSelectedFile();      if (file.exists()) {         action = JOptionPane.showConfirmDialog(this,                     "Replace existing file?");         if (action != JOptionPane.YES_OPTION)            return;      }      try {         PrintWriter out = new PrintWriter(new FileWriter(file));         String contents = text.getText();         out.print(contents);         if (out.checkError())            throw new IOException("Error while writing to file.");         out.close();      }      catch (IOException e) {        JOptionPane.showMessageDialog(this,             "Sorry, an error has occurred:\n" + e.getMessage());      }   }   private void doOpen() {      File file;         JFileChooser fd; // File dialog              fd = new JFileChooser(new File("."));      fd.setDialogTitle("Open File...");      int action = fd.showOpenDialog(this);      if (action != JFileChooser.APPROVE_OPTION) {          return;      }      file = fd.getSelectedFile();      try {         TextReader in = new TextReader(new FileReader(file));          String line;         text.setText("");         int lineCt = 0;         while (lineCt < 1000 && in.peek() != '\0') {            line = in.getln();            text.append(line + '\n');            lineCt++;         }         if (in.eof() == false)         text.append("\n\n******* Text truncated to 1000 lines! *******\n");         in.close();      }      catch (Exception e) {        JOptionPane.showMessageDialog(this,                "Sorry, some error occurred:\n" + e.getMessage());      }   } 	//public Image doCompress()         public void doCompress()	{		String tempText, tempToken;		int allWords, textSize=0, arrayTS=0, Pi=0, foundIn=0;		textArray = new String[1000];		//myPixel = new int[10000];		//R = new double[10000];		//G = new double[10000];		//B = new double[10000];                Image generatedImage;                   		tempText = text.getText();		//System.out.println(tempText);		        StringTokenizer tokens = new StringTokenizer( tempText );				allWords=tokens.countTokens();				//System.out.println(allWords);					while ( tokens.hasMoreTokens() )		{			tempToken=tokens.nextToken();			textSize+=tempToken.length();						foundIn=linearSearch(textArray,tempToken);						if(foundIn==(-1))			{ 				textArray[index]=tempToken;            	myPixels[Pi]=index;            //	System.out.println( textArray[index] + "\n" );            	arrayTS+=textArray[index].length();            	index++;            	        	}//if        	else{        		myPixels[Pi]=foundIn;        	}                        //Convert the indices into a Pixel(RGB)        	         	R[Pi] =  myPixels[Pi]/(256*256);        	G[Pi] = ( myPixels[Pi] - (256 * 256 * R[Pi]) ) / 256;        	B[Pi] = ( myPixels[Pi] - (256 * 256 * R[Pi]) ) - (256*G[Pi]);        	Pi++;        }//while                     System.out.println("All Words="+allWords+"\nDiff Words="+ index+"\n");     System.out.println("Actual Text Size="+textSize+" bytes");     System.out.println("Compressed Text Size="+(3*allWords+arrayTS)+" bytes");   }// doCompress      public int linearSearch( String array[], String key )    {         for ( int n = 0; n < index; n++ )          //if ( array[ n ] == key )         if( array[ n ].compareTo( key )==0 )            return n;      return -1;   }   public void doViewImage()    {               App viewImage ;       viewImage = new App();        }     private void doQuit()    {      System.exit(0);   }}  class demoframe extends Frame {	Label label1; demoframe(String title){     super(title);     setLocation(100,100);     ImageIcon image = new ImageIcon("output.bmp");     JLabel label = new JLabel();     label.setIcon(image);     add(label);}}/*************************************************************************/class App extends JFrame{     ImageWindow wnd;       App ()    {       BufferedImage image = paintImage();       ImageWindow wnd = new ImageWindow(image);            wnd.setJMenuBar(makeButtons());       //wnd.show();       wnd.setVisible(true);           }    private JMenuBar makeButtons() {       ActionListener listener = new ActionListener() {                 public void actionPerformed(ActionEvent evt) {               String cmd = evt.getActionCommand();                               if (cmd.equals("Extract Text")) {}                                  if (cmd.equals("QUIT")){                  doQuitImage();                 }            }         };               JButton ExtractButton = new JButton("Extract Text");      ExtractButton.setEnabled( true );      ExtractButton.addActionListener(listener);                JButton QuitButton = new JButton("QUIT");      QuitButton.setEnabled( true );      QuitButton.addActionListener(listener);                             JMenuBar bar = new JMenuBar();      bar.add(ExtractButton);      bar.add(QuitButton);            return bar;   }      private void doQuitImage()    {      //wnd.setVisible(false);      System.exit(0);   }        public static BufferedImage paintImage()    {       int XX = 256*256 ;        int[] R, G, B;        R = new int [XX];        G = new int [XX];        B = new int [XX];        Image image_in_file;                 for (int i=0; i<= 255*255; i++)        {       R = i/(256*256) ;        	G = (i - (256 * 256 * R)) / 256 ;        	B = (i - (256 * 256 * R)) - (256*G) ;        }                 BufferedImage image =            new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);                int[] pixels = new int[256*256];                // Fill array with color values        for ( int x = 0; x != 256; ++x )        {            for ( int y = 0; y != 256; ++y )            {                int index = 256*y+x;                pixels[index] = makeRGB(R[index], G[index], B[index]); //(0xFF << 24) | (x * y + 100);            }        }                // Write colors to image        image.setRGB(0, 0, 256, 256, pixels, 0, 256);        try{ ImageIO.write(image,"JPG", new File("output.JPG"));}                 catch (IOException e) {System.out.println(e);}        //image_in_file = createImage(new MemoryImageSource(256, 256, pixels,0,256));  int bitMap [];                         bitMap  = new int [256*256];        // U have to use image generated up                          PixelGrabber pg = new PixelGrabber(image,0,0,256,256,bitMap,0,256);         try{            pg.grabPixels();        } catch (InterruptedException e) {         e.printStackTrace ();        // return;        }        if ((pg.getStatus() & ImageObserver.ABORT) != 0)        { System.err.println("Pixel grab not successful");        //  return;        }         for ( int x = 0; x != 256; ++x )        {            for ( int y = 0; y != 256; ++y )            {                int index = 256*y+x;                int pixel = bitMap[index];                // u have to use R[], G[], B[]                 int alpha = (pixel >> 24) & 0xFF;                 R[index] = (pixel >> 16) & 0xFF;                  G[index] = (pixel >> 8) & 0xFF;                  B[index] = (pixel  ) & 0xFF;                 int Windex = (256 * 256)* R[index] + 256 * G[index] + B[index];                             }        }         return image;    }    // r,g,b should be >= 0 and <= 255, otherwise    // you will get strange results    private static int makeRGB(int r, int g, int b)    {        return (0xFF << 24) | (r << 16) | (g << 8) | b;    }    }/**************************************************************************//*class extractPixel{       extractPixel ()    {               } private static void extractPixels()    {         int bitMap [];                         bitMap  = new int [256*256];        // U have to use image generated up        Image image;                  PixelGrabber pg = new PixelGrabber(image,0,0,256,256,bitMap,0,256);         try{            pg.grabPixels();        } catch (InterruptedException e) {         e.printStackTrace ();         return;        }        if ((pg.getStatus() & ImageObserver.ABORT) != 0)        { System.err.println("Pixel grab not successful");          return;        }         for ( int x = 0; x != 256; ++x )        {            for ( int y = 0; y != 256; ++y )            {                int index = 256*y+x;                int pixel = bitMap[index];                // u have to use R[], G[], B[]                 int alpha = (pixel >> 24) & 0xFF;                 int red = (pixel >> 16) & 0xFF;                  int green = (pixel >> 8) & 0xFF;                  int  blue = (pixel  ) & 0xFF;            }        }    }      } */

[source = "cpp"]/*       This file defines the Class TextReader as a subclass of FilterReader..    The TextReader provides methods for reading data expressed in human-readable    ASCII text format.        This file also defines three public subclasses of RuntimeException to represent    errors that can occur during input.  These classes are static nested inside the    TextReader class.        This is a modest variation on an earlier class called AsciiInputStream, which served    a similar function for Java 1.0, where InputStreams are used instead of Readers    for character input.        David Eck    August 18, 1998    */   import java.io.*;public class TextReader extends FilterReader {    // ************************** Exception Classes *******************************		// First, define the exceptions that can be thrown by this class.  These exceptions		// are subclasses of RuntimeException, so they do not require mandatory error-handling.		// Also, if you prefer, you can turn off excpetions by calling the IOCheck() method.		// In that case, when an exception occurs during processing by one of the methods		// of the TextReader class, an errorFlag is set but no exception is thrown.		// If you use this alternative error-handling strategy, then you should call the		// checkError() method after each input operation to see whether the operation		// completed successfully.		public static class Error extends RuntimeException {		      // Represents any excpetion that occurs in the TextReader Class.		      // In fact, only general IOExceptions are translated directly into		      // TextReader.Error.  Other exceptions throw objects belonging		      // to one of the following subclasses of TextReader.Error.		   Error(String errorMessage) {		      super(errorMessage);		   }		}		public static class FormatError extends Error {		      // Illegal data: an illegal number or an illegal boolean value		   FormatError(String errorMessage) {		      super(errorMessage);		   }		}		public static class EOFError extends Error {		     // attempt to read past end of stream		   EOFError(String errorMessage) {		      super(errorMessage);		   }		}   // ***************************** Constructors ********************************      public TextReader(BufferedReader s) {      super(s);   }      public TextReader(Reader s) {      super(new BufferedReader(s));   }      public TextReader(InputStream s) {      super( new BufferedReader(new InputStreamReader(s)) );   }      // ***************************** Error Checking *****************************   public void IOCheck(boolean throwExceptions) {  // call IOCheck(false) to turn      throwExceptionOnError = throwExceptions;     //   off exceptions, then check   }                                               //   for errors by calling checkError()      public boolean error() {   // returns true if the most recent input operation on      return errorFlag;       // this TextReader produced an error.  An error   }                          // message can be retrieved by calling getErrorMessage()      public String getErrorMessage() {            // if the most recent operation on      return errorFlag ? errorMessage : null;   // this TextReader produced an error, this   }                                            // gets an error message for that error   // *************************** Input Methods ********************************         // peek()  -- returns the next character about to be read from the stream,      //     without removing it from the stream.  '\n' is returned if the next      //     thing in the stream is end-of-line.  '\0' is returned if the next      //     thing is end-of-file.  (There is no way for peek() to distinguish      //     between EOF and a null character in the input data.  Use eof() to      //     test for end-of-file.)            // getAnyChar() -- reads and returns the next character in the stream, even if it      //     is a whitespace character.  It is an error to read past end-of-file.      //     (Note that getChar() skips over whitespace characters before reading.)            // getChar(), getByte(), etc. -- skip over whitespace characters, then try to read a      //     value of the specified type.  An error can occur if the right type of data      //     is not found.  A "word" is any sequence of non-whitespace characters.      //     A "boolean" is one of the words (ignoring case) "true", "false", "yes", "no"      //     "t", "f", "y", "n", "0", "1".  An "Alpha" is a sequence of letters.  getAlpha()      //     is a special case in that it will skip over all non-letters before reading,      //     rather than just skipping whitespace characters.            // getln() -- reads all characters up to the next end-of-line and returns them      //     as a String.  The end-of-line is then read and discarded.            // getlnChar(), getlnByte() etc. -- Work the same as getChar(), etc., except that      //     after the value is read, any other characters on the same line, including the      //     end-of-line, are read and discarded.            // eoln() -- this first reads and discards any spaces and tabs.  Then tests whether      //     the next thing in the stream is an end-of-line.  The end-of-file also counts      //     as an end of line.  If you want to test for eoln without discarding spaces      //     and tabs, check whether peek() == '\n' or '\0'.         // eof() -- this first reads and discards any spaces, ends-of-line and tabs.  Then tests      //     whether the next thing in the stream is the end-of-file.  If you want to test for      //     eof without discarding spaces, ends-of-line, and tabs, check whether peek() == '\0'.            // skipWhiteSpace() -- reads and discards any whitespace characters (spaces, tabs, and      //     end-of-lines).  Stops when the next character is a non-whitespace character or is eof.            // skipNonLetters() -- reads and discards any non-letters, stopping when the next character      //     is a letter or the end-of-file.      public char peek()          { errorFlag = false; return lookChar(); }      public char getAnyChar()    { errorFlag = false; return readChar(); }   public char getChar()       { errorFlag = false; skipWhiteSpace(); return readChar(); }   public byte getByte()       { errorFlag = false; return (byte)readInteger(-128L,127L); }   public short getShort()     { errorFlag = false; return (short)readInteger(-32768L,32767L); }      public int getInt()         { errorFlag = false; return (int)readInteger((long)Integer.MIN_VALUE, (long)Integer.MAX_VALUE); }   public long getLong()       { errorFlag = false; return readInteger(Long.MIN_VALUE, Long.MAX_VALUE); }   public float getFloat()     { errorFlag = false; return readFloat(); }   public double getDouble()   { errorFlag = false; return readDouble(); }   public boolean getBoolean() { errorFlag = false; return readBoolean(); }   public String getWord()     { errorFlag = false; return readWord(); }   public String getAlpha()    { errorFlag = false; return readAlpha(); }      public String getln()         { errorFlag = false; return readLine(); }   public char getlnChar()       { char x=getChar();       dropLine();  return x; }   public byte getlnByte()       { byte x=getByte();       dropLine();  return x; }   public short getlnShort()     { short x=getShort();     dropLine();  return x; }   public int getlnInt()         { int x=getInt();         dropLine();  return x; }   public long getlnLong()       { long x=getLong();       dropLine();  return x; }   public float getlnFloat()     { float x=getFloat();     dropLine();  return x; }   public double getlnDouble()   { double x=getDouble();   dropLine();  return x; }   public boolean getlnBoolean() { boolean x=getBoolean(); dropLine();  return x; }   public String getlnWord()     { String x=getWord();     dropLine();  return x; }   public String getlnAlpha()    { String x=getAlpha();    dropLine();  return x; }      public boolean eoln() {      char ch = lookChar();      while (!EOF && !errorFlag && (ch == ' ' || ch == '\t')) {         readChar();         ch = lookChar();      }      return (ch == '\n' || EOF);   }      public boolean eof() {      char ch = lookChar();      while (!EOF && !errorFlag && (ch == ' ' || ch == '\n' || ch == '\t')) {         readChar();         ch = lookChar();      }      return EOF;   }      public void skipWhiteSpace() {      char ch = lookChar();      while (!errorFlag && (ch == ' ' || ch == '\n' || ch == '\t')) {         readChar();         ch = lookChar();      }   }      public void skipNonLetters() {      char ch = lookChar();      while (!errorFlag && !EOF && !Character.isLetter(ch)) {         readChar();         ch = lookChar();      }   }      public void close() {      errorFlag = false;      try {         in.close();      }      catch (IOException e) {         errorFlag = true;         errorMessage = e.toString();      }   }   // *************************** private implementation stuff ***********************      private int lookAhead = -1;          // one-character buffer; -1 indicates the buffer is empty   private boolean errorFlag = false;    // set to true if most recent operation produced an error   private String errorMessage = "";     // error message for the most recent error   private boolean EOF = false;          // has the end-of-stream been encountered?   private boolean throwExceptionOnError = true;  // determines which type of error-handling is used      // Three utility routines for throwing exceptions.      private void doError(String message) {      errorFlag = true;      errorMessage = message;      if (throwExceptionOnError)         throw new Error(message);   }      private void doFormatError(String message) {      errorFlag = true;      errorMessage = message;      if (throwExceptionOnError)         throw new FormatError(message);   }      private void doEOFError(String message) {      errorFlag = true;      errorMessage = message;      if (throwExceptionOnError)         throw new FormatError(message);   }      // The remaining methods are basic methods for reading the various types of   // data from the stream      private char readChar() {      char ch = lookChar();      if (EOF)         doEOFError("Attempt to read past end-of-data in input stream.");      lookAhead = -1;      return ch;   }      private boolean possibleLineFeedPending = false;  // for dealing with \r\n pairs      private char lookChar() {      if (lookAhead != -1) {         if (lookAhead == '\r')            return '\n';         else           return (char)lookAhead;      }      if (EOF)         return '\0';      try {         int n = in.read();         if (n == '\n' && possibleLineFeedPending) {  // ignore \n of \r\n pair            n = in.read();         }         possibleLineFeedPending = (n == '\r');         lookAhead = n;         if (lookAhead == -1) {            EOF = true;            return '\0';         }      }      catch (IOException e) {         doError(e.getMessage());      }      if (lookAhead == '\r')  // represent all eoln's with \n         lookAhead = '\n';      return (char)lookAhead;   }      private void dropLine() {      while (!errorFlag) {         if (lookChar() == '\0')            return;         if (readChar() == '\n')            return;      }   }      private String readLine() {      StringBuffer s = new StringBuffer(100);      char ch = readChar();      while (!errorFlag && ch != '\n') {         s.append(ch);         ch = lookChar();         if (ch == '\0')            break;         ch = readChar();      }      return s.toString();   }      private String readWord() {      skipWhiteSpace();      if (errorFlag)         return null;      StringBuffer s = new StringBuffer(50);      char ch = lookChar();      if (EOF) {         doEOFError("Attempt to read past end-of-data");         return null;      }      while (!errorFlag && !EOF && ch != '\n' && ch != ' ' && ch != '\t') {         s.append(readChar());         ch = lookChar();      }      return s.toString();   }         private String readAlpha() {      skipNonLetters();      if (errorFlag)         return null;      StringBuffer s = new StringBuffer(50);      char ch = lookChar();      if (EOF) {         doEOFError("Attempt to read past end-of-data");         return null;      }      while (!errorFlag && Character.isLetter(ch)) {         s.append(readChar());         ch = lookChar();      }      return s.toString();   }         public float readFloat() {      double d = readDouble();      if (errorFlag)         return Float.NaN;      if (Math.abs(d) > Float.MAX_VALUE)         doFormatError("Input number outside of legal range for values of type float");      return (float)d;   }      public double readDouble() {      double x = Double.NaN;      StringBuffer s=new StringBuffer(50);      skipWhiteSpace();      char ch = lookChar();      if (ch == '-' || ch == '+') {          s.append(readChar());          skipWhiteSpace();          ch = lookChar();      }      if ( (ch < '0' || ch > '9') && (ch != '.') ) {         if (EOF)            doEOFError("Expecting a floating-point number and found end-of-data");         else            doFormatError("Expecting a floating-point number and found \""  + ch + "\"" );         return Double.NaN;      }      boolean digits = false;      while (ch >= '0' && ch <= '9') {          s.append(readChar());          ch = lookChar();          digits = true;      }      if (ch == '.') {         s.append(readChar());         ch = lookChar();         while (ch >= '0' && ch <= '9') {             s.append(readChar());             ch = lookChar();             digits = true;         }      }      if (!digits) {         doFormatError("No digits found in floating-point input.");         return Double.NaN;      }      if (ch == 'E' || ch == 'e') {         s.append(readChar());         ch = lookChar();         if (ch == '-' || ch == '+') {             s.append(readChar());             ch = lookChar();         }         if ( (ch < '0' || ch > '9') && (ch != '.') ) {            if (EOF)               doEOFError("Expecting exponent for a floating-point number and found end-of-data");            else               doFormatError("Expecting exponent for a floating-point number and found \""  + ch + "\"");            return Double.NaN;         }         while (ch >= '0' && ch <= '9') {             s.append(readChar());             ch = lookChar();         }      }      String str = s.toString();      Double d;      try {         d = new Double(str);         x = d.doubleValue();      }      catch (NumberFormatException e) {         x = Double.NaN;      }      if (Double.isNaN(x) || Double.isInfinite(x)) {         doFormatError("Illegal floating point number");         return Double.NaN;      }            return x;   }      public boolean readBoolean() {      boolean ans = false;      String s = getWord();      if (errorFlag)         return false;      if ( s.equalsIgnoreCase("true") || s.equalsIgnoreCase("t") ||                 s.equalsIgnoreCase("yes")  || s.equalsIgnoreCase("y") ||                 s.equals("1") ) {           ans = true;       }       else if ( s.equalsIgnoreCase("false") || s.equalsIgnoreCase("f") ||                 s.equalsIgnoreCase("no")  || s.equalsIgnoreCase("n") ||                 s.equals("0") ) {           ans = false;       }       else          doFormatError("Illegal input for value of type boolean: \"" + s + "\"");       return ans;   }   private long readInteger(long min, long max) {  // read long integer, limited to specified range      skipWhiteSpace();      if (errorFlag)         return 0;      char sign = '+';      if (lookChar() == '-' || lookChar() == '+') {         sign = getChar();         skipWhiteSpace();      }      long n = 0;      char ch = lookChar();      if (ch < '0' || ch > '9') {         if (EOF)            doEOFError("Expecting an integer and found end-of-data");         else            doFormatError("Expecting an integer and found \""  + ch + "\"");         return 0;      }      while (!errorFlag && ch >= '0' && ch <= '9') {         readChar();         n = 10*n + (int)ch - (int)'0';         if (n < 0) {            doFormatError("Integer value outside of legal range");            return 0;         }         ch = lookChar();      }      if (sign == '-')         n = -n;      if (n < min || n > max) {         doFormatError("Integer value outside of legal range");         return 0;      }      return n;   }      // Override the read() methods from FilterReader so that they will work if a   // TextReader is wrapped inside another file.  (This is necessary to take   // lookAhead into account.)      public int read() throws IOException {      if (lookAhead == -1)         return super.read();      else {         int x = lookAhead;         lookAhead = -1;         return x;      }   }      public int read(char[] buffer, int offset, int count) throws IOException {      if (lookAhead == -1 || count <= 0)         return super.read(buffer,offset,count);      else if (count == 1) {         buffer[offset] = (char)lookAhead;         lookAhead = -1;         return 1;      }      else {         buffer[offset] = (char)lookAhead;         lookAhead = -1;         int ct = super.read(buffer,offset+1,count-1);         return ct + 1;      }   }   } // end of class TextReader