URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [imageio/] [stream/] [ImageInputStreamImpl.java] - Blame information for rev 775

Go to most recent revision | Details | Compare with Previous | View Log


/* ImageInputStream.java --
   Copyright (C) 2004  Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
 
package javax.imageio.stream;
 
import gnu.java.lang.CPStringBuilder;
 
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteOrder;
import java.util.Stack;
 
/**
 * @author Michael Koch (konqueror@gmx.de)
 */
public abstract class ImageInputStreamImpl implements ImageInputStream
{
  private boolean closed;
  private Stack markStack = new Stack();
 
  byte[] buffer = new byte[8];
 
  protected int bitOffset;
  protected ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
  protected long flushedPos;
  protected long streamPos;
 
  public ImageInputStreamImpl()
  {
    // Do nothing here.
  }
 
  protected final void checkClosed()
    throws IOException
  {
    if (closed)
      throw new IOException("stream closed");
  }
 
  public void close()
    throws IOException
  {
    checkClosed();
    closed = true;
  }
 
  protected void finalize()
    throws Throwable
  {
    if (!closed)
      close();
  }
 
  public void flush()
    throws IOException
  {
    flushBefore(getStreamPosition());
  }
 
  public void flushBefore(long position)
    throws IOException
  {
    if (position < flushedPos)
      throw new IndexOutOfBoundsException();
 
    if (position > streamPos)
      throw new IndexOutOfBoundsException();
 
    flushedPos = position;
  }
 
  public int getBitOffset()
    throws IOException
  {
    checkClosed();
    return bitOffset;
  }
 
  public ByteOrder getByteOrder()
  {
    return byteOrder;
  }
 
  public long getFlushedPosition()
  {
    return flushedPos;
  }
 
  public long getStreamPosition()
    throws IOException
  {
    checkClosed();
    return streamPos;
  }
 
  public boolean isCached()
  {
    return false;
  }
 
  public boolean isCachedFile()
  {
    return false;
  }
 
  public boolean isCachedMemory()
  {
    return false;
  }
 
  public long length()
  {
    return -1L;
  }
 
  public void mark()
  {
    try
      {
        markStack.push(new Long(getStreamPosition()));
      }
    catch (IOException e)
      {
        throw new RuntimeException(e);
      }
  }
 
  public abstract int read()
    throws IOException;
 
  public abstract int read(byte[] data, int offset, int len)
    throws IOException;
 
  public int read(byte[] data)
    throws IOException
  {
    return read(data, 0, data.length);
  }
 
  public int readBit()
    throws IOException
  {
    checkClosed();
 
    // Calculate new bit offset here as readByte clears it.
    int newOffset = (bitOffset + 1) & 0x7;
 
    // Clears bitOffset.
    byte data = readByte();
 
    // If newOffset is 0 it means we just read the 8th bit in a byte
    // and therefore we want to advance to the next byte.  Otherwise
    // we want to roll back the stream one byte so that future readBit
    // calls read bits from the same current byte.
    if (newOffset != 0)
      {
        seek(getStreamPosition() - 1);
        data = (byte) (data >> (8 - newOffset));
      }
 
    bitOffset = newOffset;
    return data & 0x1;
  }
 
  public long readBits(int numBits)
    throws IOException
  {
    checkClosed();
 
    if (numBits < 0 || numBits > 64)
      throw new IllegalArgumentException();
 
    long bits = 0L;
 
    for (int i = 0; i < numBits; i++)
      {
        bits <<= 1;
        bits |= readBit();
      }
    return bits;
  }
 
  public boolean readBoolean()
    throws IOException
  {
    byte data = readByte();
 
    return data != 0;
  }
 
  public byte readByte()
    throws IOException
  {
    checkClosed();
 
    int data = read();
 
    if (data == -1)
      throw new EOFException();
 
    return (byte) data;
  }
 
  public void readBytes(IIOByteBuffer buffer, int len)
    throws IOException
  {
    readFullyPrivate(buffer.getData(), buffer.getOffset(), len);
 
    buffer.setLength(len);
  }
 
  public char readChar()
    throws IOException
  {
    return (char) readShort();
  }
 
  public double readDouble()
    throws IOException
  {
    return Double.longBitsToDouble(readLong());
  }
 
  public float readFloat()
    throws IOException
  {
    return Float.intBitsToFloat(readInt());
  }
 
  public void readFully(byte[] data)
    throws IOException
  {
    readFully(data, 0, data.length);
  }
 
  public void readFully(byte[] data, int offset, int len)
    throws IOException
  {
    readFullyPrivate(data, offset, len);
  }
 
  public void readFully(char[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readChar();
  }
 
  public void readFully(double[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readDouble();
  }
 
  public void readFully(float[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readFloat();
  }
 
  public void readFully(int[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readInt();
  }
 
  public void readFully(long[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readLong();
  }
 
  public void readFully(short[] data, int offset, int len)
    throws IOException
  {
    for (int i = 0; i < len; ++i)
      data[offset + i] = readShort();
  }
 
  public int readInt()
    throws IOException
  {
    readFullyPrivate(buffer, 0, 4);
 
    if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
      return (int)
        (((int) (buffer[0] & 0xff) << 0)
         | ((int) (buffer[1] & 0xff) << 8)
         | ((int) (buffer[2] & 0xff) << 16)
         | ((int) (buffer[3] & 0xff) << 24));
 
    return (int)
      (((int) (buffer[0] & 0xff) << 24)
       + ((int) (buffer[1] & 0xff) << 16)
       + ((int) (buffer[2] & 0xff) << 8)
       + ((int) (buffer[3] & 0xff) << 0));
  }
 
  public String readLine()
    throws IOException
  {
    checkClosed();
 
    int c = -1;
    boolean eol = false;
    CPStringBuilder buffer = new CPStringBuilder();
 
    c = read();
    if (c == -1)
      return null;
 
    while (!eol)
      {
        switch(c)
          {
          case '\r':
            // Check for following '\n'.
            long oldPosition = getStreamPosition();
            c = read();
            if (c == -1 || c == '\n')
              eol = true;
            else
              {
                seek(oldPosition);
                eol = true;
              }
            continue;
 
          case '\n':
            eol = true;
            continue;
 
          default:
            buffer.append((char) c);
            break;
          }
        c = read();
        if (c == -1)
          eol = true;
      }
 
    return buffer.toString();
  }
 
  public long readLong()
    throws IOException
  {
    readFullyPrivate(buffer, 0, 8);
 
    if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
      return (long)
        (((long) (buffer[0] & 0xff) << 0)
         | ((long) (buffer[1] & 0xff) << 8)
         | ((long) (buffer[2] & 0xff) << 16)
         | ((long) (buffer[3] & 0xff) << 24)
         | ((long) (buffer[4] & 0xff) << 32)
         | ((long) (buffer[5] & 0xff) << 40)
         | ((long) (buffer[6] & 0xff) << 48)
         | ((long) (buffer[7] & 0xff) << 56));
 
    return  (long)
      (((long) (buffer[0] & 0xff) << 56)
       | ((long) (buffer[1] & 0xff) << 48)
       | ((long) (buffer[2] & 0xff) << 40)
       | ((long) (buffer[3] & 0xff) << 32)
       | ((long) (buffer[4] & 0xff) << 24)
       | ((long) (buffer[5] & 0xff) << 16)
       | ((long) (buffer[6] & 0xff) << 8)
       | ((long) (buffer[7] & 0xff) << 0));
  }
 
  public short readShort()
    throws IOException
  {
    readFullyPrivate(buffer, 0, 2);
 
    if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
      return (short)
        (((short) (buffer[0] & 0xff) << 0)
         | ((short) (buffer[1] & 0xff) << 8));
 
    return (short)
      (((short) (buffer[0] & 0xff) << 8)
       | ((short) (buffer[1] & 0xff) << 0));
  }
 
  public int readUnsignedByte()
    throws IOException
  {
    return (int) readByte() & 0xff;
  }
 
  public long readUnsignedInt()
    throws IOException
  {
    return (long) readInt() & 0xffffffffL;
  }
 
  public int readUnsignedShort()
    throws IOException
  {
    return (int) readShort() & 0xffff;
  }
 
  public String readUTF()
    throws IOException
  {
    checkClosed();
 
    String data;
    ByteOrder old = getByteOrder();
    // Strings are always big endian.
    setByteOrder(ByteOrder.BIG_ENDIAN);
 
    try
      {
        data = DataInputStream.readUTF(this);
      }
    finally
      {
        setByteOrder(old);
      }
 
    return data;
  }
 
  public void reset()
    throws IOException
  {
    checkClosed();
 
    long mark = ((Long) markStack.pop()).longValue();
    seek(mark);
  }
 
  public void seek(long position)
    throws IOException
  {
    checkClosed();
 
    if (position < getFlushedPosition())
      throw new IndexOutOfBoundsException("position < flushed position");
 
    streamPos = position;
    bitOffset = 0;
  }
 
  public void setBitOffset (int bitOffset)
    throws IOException
  {
    checkClosed();
 
    if (bitOffset < 0 || bitOffset > 7)
      throw new IllegalArgumentException("bitOffset not between 0 and 7 inclusive");
 
    this.bitOffset = bitOffset;
  }
 
  public void setByteOrder(ByteOrder byteOrder)
  {
    this.byteOrder = byteOrder;
  }
 
  public int skipBytes(int num)
    throws IOException
  {
    checkClosed();
 
    seek(getStreamPosition() + num);
    bitOffset = 0;
    return num;
  }
 
  public long skipBytes(long num)
    throws IOException
  {
    checkClosed();
 
    seek(getStreamPosition() + num);
    bitOffset = 0;
    return num;
  }
 
  private void readFullyPrivate (byte[] buf, int offset, int len) throws IOException
  {
    checkClosed();
 
    if (len < 0)
      throw new IndexOutOfBoundsException("Negative length: " + len);
 
    while (len > 0)
      {
        // read will block until some data is available.
        int numread = read (buf, offset, len);
        if (numread < 0)
          throw new EOFException ();
        len -= numread;
        offset += numread;
      }
    bitOffset = 0;
  }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [imageio/] [stream/] [ImageInputStreamImpl.java] - Blame information for rev 775

Line No.	Rev	Author	Line
1	772	jeremybenn	`/* ImageInputStream.java --`
2			`Copyright (C) 2004 Free Software Foundation, Inc.`
3
4			`This file is part of GNU Classpath.`
5
6			`GNU Classpath is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2, or (at your option)`
9			`any later version.`
10
11			`GNU Classpath is distributed in the hope that it will be useful, but`
12			`WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
14			`General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with GNU Classpath; see the file COPYING. If not, write to the`
18			`Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA`
19			`02110-1301 USA.`
20
21			`Linking this library statically or dynamically with other modules is`
22			`making a combined work based on this library. Thus, the terms and`
23			`conditions of the GNU General Public License cover the whole`
24			`combination.`
25
26			`As a special exception, the copyright holders of this library give you`
27			`permission to link this library with independent modules to produce an`
28			`executable, regardless of the license terms of these independent`
29			`modules, and to copy and distribute the resulting executable under`
30			`terms of your choice, provided that you also meet, for each linked`
31			`independent module, the terms and conditions of the license of that`
32			`module. An independent module is a module which is not derived from`
33			`or based on this library. If you modify this library, you may extend`
34			`this exception to your version of the library, but you are not`
35			`obligated to do so. If you do not wish to do so, delete this`
36			`exception statement from your version. */`
37
38
39			`package javax.imageio.stream;`
40
41			`import gnu.java.lang.CPStringBuilder;`
42
43			`import java.io.DataInputStream;`
44			`import java.io.EOFException;`
45			`import java.io.IOException;`
46			`import java.nio.ByteOrder;`
47			`import java.util.Stack;`
48
49			`/**`
50			`* @author Michael Koch (konqueror@gmx.de)`
51			`*/`
52			`public abstract class ImageInputStreamImpl implements ImageInputStream`
53			`{`
54			`private boolean closed;`
55			`private Stack markStack = new Stack();`
56
57			`byte[] buffer = new byte[8];`
58
59			`protected int bitOffset;`
60			`protected ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;`
61			`protected long flushedPos;`
62			`protected long streamPos;`
63
64			`public ImageInputStreamImpl()`
65			`{`
66			`// Do nothing here.`
67			`}`
68
69			`protected final void checkClosed()`
70			`throws IOException`
71			`{`
72			`if (closed)`
73			`throw new IOException("stream closed");`
74			`}`
75
76			`public void close()`
77			`throws IOException`
78			`{`
79			`checkClosed();`
80			`closed = true;`
81			`}`
82
83			`protected void finalize()`
84			`throws Throwable`
85			`{`
86			`if (!closed)`
87			`close();`
88			`}`
89
90			`public void flush()`
91			`throws IOException`
92			`{`
93			`flushBefore(getStreamPosition());`
94			`}`
95
96			`public void flushBefore(long position)`
97			`throws IOException`
98			`{`
99			`if (position < flushedPos)`
100			`throw new IndexOutOfBoundsException();`
101
102			`if (position > streamPos)`
103			`throw new IndexOutOfBoundsException();`
104
105			`flushedPos = position;`
106			`}`
107
108			`public int getBitOffset()`
109			`throws IOException`
110			`{`
111			`checkClosed();`
112			`return bitOffset;`
113			`}`
114
115			`public ByteOrder getByteOrder()`
116			`{`
117			`return byteOrder;`
118			`}`
119
120			`public long getFlushedPosition()`
121			`{`
122			`return flushedPos;`
123			`}`
124
125			`public long getStreamPosition()`
126			`throws IOException`
127			`{`
128			`checkClosed();`
129			`return streamPos;`
130			`}`
131
132			`public boolean isCached()`
133			`{`
134			`return false;`
135			`}`
136
137			`public boolean isCachedFile()`
138			`{`
139			`return false;`
140			`}`
141
142			`public boolean isCachedMemory()`
143			`{`
144			`return false;`
145			`}`
146
147			`public long length()`
148			`{`
149			`return -1L;`
150			`}`
151
152			`public void mark()`
153			`{`
154			`try`
155			`{`
156			`markStack.push(new Long(getStreamPosition()));`
157			`}`
158			`catch (IOException e)`
159			`{`
160			`throw new RuntimeException(e);`
161			`}`
162			`}`
163
164			`public abstract int read()`
165			`throws IOException;`
166
167			`public abstract int read(byte[] data, int offset, int len)`
168			`throws IOException;`
169
170			`public int read(byte[] data)`
171			`throws IOException`
172			`{`
173			`return read(data, 0, data.length);`
174			`}`
175
176			`public int readBit()`
177			`throws IOException`
178			`{`
179			`checkClosed();`
180
181			`// Calculate new bit offset here as readByte clears it.`
182			`int newOffset = (bitOffset + 1) & 0x7;`
183
184			`// Clears bitOffset.`
185			`byte data = readByte();`
186
187			`// If newOffset is 0 it means we just read the 8th bit in a byte`
188			`// and therefore we want to advance to the next byte. Otherwise`
189			`// we want to roll back the stream one byte so that future readBit`
190			`// calls read bits from the same current byte.`
191			`if (newOffset != 0)`
192			`{`
193			`seek(getStreamPosition() - 1);`
194			`data = (byte) (data >> (8 - newOffset));`
195			`}`
196
197			`bitOffset = newOffset;`
198			`return data & 0x1;`
199			`}`
200
201			`public long readBits(int numBits)`
202			`throws IOException`
203			`{`
204			`checkClosed();`
205
206			`if (numBits < 0 \|\| numBits > 64)`
207			`throw new IllegalArgumentException();`
208
209			`long bits = 0L;`
210
211			`for (int i = 0; i < numBits; i++)`
212			`{`
213			`bits <<= 1;`
214			`bits \|= readBit();`
215			`}`
216			`return bits;`
217			`}`
218
219			`public boolean readBoolean()`
220			`throws IOException`
221			`{`
222			`byte data = readByte();`
223
224			`return data != 0;`
225			`}`
226
227			`public byte readByte()`
228			`throws IOException`
229			`{`
230			`checkClosed();`
231
232			`int data = read();`
233
234			`if (data == -1)`
235			`throw new EOFException();`
236
237			`return (byte) data;`
238			`}`
239
240			`public void readBytes(IIOByteBuffer buffer, int len)`
241			`throws IOException`
242			`{`
243			`readFullyPrivate(buffer.getData(), buffer.getOffset(), len);`
244
245			`buffer.setLength(len);`
246			`}`
247
248			`public char readChar()`
249			`throws IOException`
250			`{`
251			`return (char) readShort();`
252			`}`
253
254			`public double readDouble()`
255			`throws IOException`
256			`{`
257			`return Double.longBitsToDouble(readLong());`
258			`}`
259
260			`public float readFloat()`
261			`throws IOException`
262			`{`
263			`return Float.intBitsToFloat(readInt());`
264			`}`
265
266			`public void readFully(byte[] data)`
267			`throws IOException`
268			`{`
269			`readFully(data, 0, data.length);`
270			`}`
271
272			`public void readFully(byte[] data, int offset, int len)`
273			`throws IOException`
274			`{`
275			`readFullyPrivate(data, offset, len);`
276			`}`
277
278			`public void readFully(char[] data, int offset, int len)`
279			`throws IOException`
280			`{`
281			`for (int i = 0; i < len; ++i)`
282			`data[offset + i] = readChar();`
283			`}`
284
285			`public void readFully(double[] data, int offset, int len)`
286			`throws IOException`
287			`{`
288			`for (int i = 0; i < len; ++i)`
289			`data[offset + i] = readDouble();`
290			`}`
291
292			`public void readFully(float[] data, int offset, int len)`
293			`throws IOException`
294			`{`
295			`for (int i = 0; i < len; ++i)`
296			`data[offset + i] = readFloat();`
297			`}`
298
299			`public void readFully(int[] data, int offset, int len)`
300			`throws IOException`
301			`{`
302			`for (int i = 0; i < len; ++i)`
303			`data[offset + i] = readInt();`
304			`}`
305
306			`public void readFully(long[] data, int offset, int len)`
307			`throws IOException`
308			`{`
309			`for (int i = 0; i < len; ++i)`
310			`data[offset + i] = readLong();`
311			`}`
312
313			`public void readFully(short[] data, int offset, int len)`
314			`throws IOException`
315			`{`
316			`for (int i = 0; i < len; ++i)`
317			`data[offset + i] = readShort();`
318			`}`
319
320			`public int readInt()`
321			`throws IOException`
322			`{`
323			`readFullyPrivate(buffer, 0, 4);`
324
325			`if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)`
326			`return (int)`
327			`(((int) (buffer[0] & 0xff) << 0)`
328			`\| ((int) (buffer[1] & 0xff) << 8)`
329			`\| ((int) (buffer[2] & 0xff) << 16)`
330			`\| ((int) (buffer[3] & 0xff) << 24));`
331
332			`return (int)`
333			`(((int) (buffer[0] & 0xff) << 24)`
334			`+ ((int) (buffer[1] & 0xff) << 16)`
335			`+ ((int) (buffer[2] & 0xff) << 8)`
336			`+ ((int) (buffer[3] & 0xff) << 0));`
337			`}`
338
339			`public String readLine()`
340			`throws IOException`
341			`{`
342			`checkClosed();`
343
344			`int c = -1;`
345			`boolean eol = false;`
346			`CPStringBuilder buffer = new CPStringBuilder();`
347
348			`c = read();`
349			`if (c == -1)`
350			`return null;`
351
352			`while (!eol)`
353			`{`
354			`switch(c)`
355			`{`
356			`case '\r':`
357			`// Check for following '\n'.`
358			`long oldPosition = getStreamPosition();`
359			`c = read();`
360			`if (c == -1 \|\| c == '\n')`
361			`eol = true;`
362			`else`
363			`{`
364			`seek(oldPosition);`
365			`eol = true;`
366			`}`
367			`continue;`
368
369			`case '\n':`
370			`eol = true;`
371			`continue;`
372
373			`default:`
374			`buffer.append((char) c);`
375			`break;`
376			`}`
377			`c = read();`
378			`if (c == -1)`
379			`eol = true;`
380			`}`
381
382			`return buffer.toString();`
383			`}`
384
385			`public long readLong()`
386			`throws IOException`
387			`{`
388			`readFullyPrivate(buffer, 0, 8);`
389
390			`if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)`
391			`return (long)`
392			`(((long) (buffer[0] & 0xff) << 0)`
393			`\| ((long) (buffer[1] & 0xff) << 8)`
394			`\| ((long) (buffer[2] & 0xff) << 16)`
395			`\| ((long) (buffer[3] & 0xff) << 24)`
396			`\| ((long) (buffer[4] & 0xff) << 32)`
397			`\| ((long) (buffer[5] & 0xff) << 40)`
398			`\| ((long) (buffer[6] & 0xff) << 48)`
399			`\| ((long) (buffer[7] & 0xff) << 56));`
400
401			`return (long)`
402			`(((long) (buffer[0] & 0xff) << 56)`
403			`\| ((long) (buffer[1] & 0xff) << 48)`
404			`\| ((long) (buffer[2] & 0xff) << 40)`
405			`\| ((long) (buffer[3] & 0xff) << 32)`
406			`\| ((long) (buffer[4] & 0xff) << 24)`
407			`\| ((long) (buffer[5] & 0xff) << 16)`
408			`\| ((long) (buffer[6] & 0xff) << 8)`
409			`\| ((long) (buffer[7] & 0xff) << 0));`
410			`}`
411
412			`public short readShort()`
413			`throws IOException`
414			`{`
415			`readFullyPrivate(buffer, 0, 2);`
416
417			`if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)`
418			`return (short)`
419			`(((short) (buffer[0] & 0xff) << 0)`
420			`\| ((short) (buffer[1] & 0xff) << 8));`
421
422			`return (short)`
423			`(((short) (buffer[0] & 0xff) << 8)`
424			`\| ((short) (buffer[1] & 0xff) << 0));`
425			`}`
426
427			`public int readUnsignedByte()`
428			`throws IOException`
429			`{`
430			`return (int) readByte() & 0xff;`
431			`}`
432
433			`public long readUnsignedInt()`
434			`throws IOException`
435			`{`
436			`return (long) readInt() & 0xffffffffL;`
437			`}`
438
439			`public int readUnsignedShort()`
440			`throws IOException`
441			`{`
442			`return (int) readShort() & 0xffff;`
443			`}`
444
445			`public String readUTF()`
446			`throws IOException`
447			`{`
448			`checkClosed();`
449
450			`String data;`
451			`ByteOrder old = getByteOrder();`
452			`// Strings are always big endian.`
453			`setByteOrder(ByteOrder.BIG_ENDIAN);`
454
455			`try`
456			`{`
457			`data = DataInputStream.readUTF(this);`
458			`}`
459			`finally`
460			`{`
461			`setByteOrder(old);`
462			`}`
463
464			`return data;`
465			`}`
466
467			`public void reset()`
468			`throws IOException`
469			`{`
470			`checkClosed();`
471
472			`long mark = ((Long) markStack.pop()).longValue();`
473			`seek(mark);`
474			`}`
475
476			`public void seek(long position)`
477			`throws IOException`
478			`{`
479			`checkClosed();`
480
481			`if (position < getFlushedPosition())`
482			`throw new IndexOutOfBoundsException("position < flushed position");`
483
484			`streamPos = position;`
485			`bitOffset = 0;`
486			`}`
487
488			`public void setBitOffset (int bitOffset)`
489			`throws IOException`
490			`{`
491			`checkClosed();`
492
493			`if (bitOffset < 0 \|\| bitOffset > 7)`
494			`throw new IllegalArgumentException("bitOffset not between 0 and 7 inclusive");`
495
496			`this.bitOffset = bitOffset;`
497			`}`
498
499			`public void setByteOrder(ByteOrder byteOrder)`
500			`{`
501			`this.byteOrder = byteOrder;`
502			`}`
503
504			`public int skipBytes(int num)`
505			`throws IOException`
506			`{`
507			`checkClosed();`
508
509			`seek(getStreamPosition() + num);`
510			`bitOffset = 0;`
511			`return num;`
512			`}`
513
514			`public long skipBytes(long num)`
515			`throws IOException`
516			`{`
517			`checkClosed();`
518
519			`seek(getStreamPosition() + num);`
520			`bitOffset = 0;`
521			`return num;`
522			`}`
523
524			`private void readFullyPrivate (byte[] buf, int offset, int len) throws IOException`
525			`{`
526			`checkClosed();`
527
528			`if (len < 0)`
529			`throw new IndexOutOfBoundsException("Negative length: " + len);`
530
531			`while (len > 0)`
532			`{`
533			`// read will block until some data is available.`
534			`int numread = read (buf, offset, len);`
535			`if (numread < 0)`
536			`throw new EOFException ();`
537			`len -= numread;`
538			`offset += numread;`
539			`}`
540			`bitOffset = 0;`
541			`}`
542			`}`