forgetest1
/
antlr
forked from jasder/antlr
1
0
Fork 0
Code Issues Pull Requests 1 Releases Wiki Activity

oops; don't need these afterall

This commit is contained in:
Terence Parr 2012-06-30 16:36:25 -07:00
parent 3900606024
commit 44355d6ff6
2 changed files with 0 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
runtime/Java/src/org/antlr/v4/runtime/LazyCharStream.java
View File

@ -1,189 +0,0 @@
/*
[The "BSD license"]
Copyright (c) 2011 Terence Parr
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.antlr.v4.runtime;
import org.antlr.v4.runtime.misc.Interval;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
/** Buffer up all char from stream, but pull chars from input on-demand,
* in a lazy fashion. This allows us build interactive programs using
* ANTLR like shells and REPLs. This is a kind of ANTLRInputStream
* that does not load() everything up front.
*/
public class LazyCharStream implements CharStream {
/** A buffer of the data being scanned */
protected char[] data;
/** This is where we will read next char. It's also how many characters
* we've actually read into the buffer. It's less than or equal
* to data.length.
*/
protected int next;
/** 0..n-1 index into string of next lookahead char. LA(1) is data[p] */
protected int p=0;
protected Reader input;
/** What is name or source of this char stream? */
public String name;
public LazyCharStream(InputStream input) {
this(input, 256);
}
public LazyCharStream(Reader input) {
this(input, 256);
}
public LazyCharStream(InputStream input, int initialSize) {
this.input = new InputStreamReader(input);
data = new char[initialSize];
}
public LazyCharStream(Reader input, int initialSize) {
this.input = input;
data = new char[initialSize];
}
public void reset() {
p = 0;
next = 0;
}
@Override
public void consume() {
sync(1); // make sure we have read current char
p++;
}
@Override
public int LA(int i) {
sync(i);
int index = p + i - 1;
if ( index < 0 ) throw new IndexOutOfBoundsException();
if ( index > next) return CharStream.EOF;
int c = data[index];
if ( c==(char)CharStream.EOF ) return CharStream.EOF;
return c;
}
/** Return a marker that we can release later. Marker happens to be
* index into buffer (not index()).
*/
@Override
public int mark() {
return -1;
}
@Override
public void release(int marker) { }
@Override
public int index() {
return p;
}
@Override
public void seek(int index) {
if ( index<=p ) {
p = index; // just jump; don't update stream state (line, ...)
return;
}
// seek forward, consume until p hits index
while ( p<index && index< next) {
consume();
}
}
/** Return num char we've read so far */
@Override
public int size() {
return next;
}
@Override
public String getSourceName() {
return name;
}
@Override
public String getText(Interval interval) {
int start = interval.a;
int stop = interval.b;
if ( stop < start ) {
throw new IllegalArgumentException("inverted interval");
}
if ( stop >= next) {
int need = stop - next + 1;
fill(need);
}
int count = stop - start + 1;
return new String(data, start, count);
}
/** Make sure we have 'want' elements from current position p. Last valid
* p index is data.size()-1. p+want-1 is the data index 'want' elements
* ahead. If we want 1 element, (p+1-1)==p must be < n.
*/
protected void sync(int want) {
// E.g., sync(1) means current p must have a char. If p>=next, we
// need a char
int need = (p+want-1) - next + 1; // how many more elements we need?
if ( need > 0 ) fill(need); // out of elements?
}
/** add n elements to buffer */
public void fill(int n) {
for (int i=1; i<=n; i++) {
try {
int c = input.read();
add(c);
if ( c==EOF ) break;
}
catch (IOException ioe) {
throw new RuntimeException(ioe);
}
}
}
protected void add(int c) {
if ( next >=data.length ) {
char[] newdata = new char[data.length*2]; // resize
System.arraycopy(data, 0, newdata, 0, data.length);
data = newdata;
}
data[next++] = (char)c;
}
}

142
tool/test/org/antlr/v4/test/TestLazyCharStream.java
View File

@ -1,142 +0,0 @@
package org.antlr.v4.test;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.LazyCharStream;
import org.antlr.v4.runtime.misc.Interval;
import org.junit.Test;
import java.io.StringReader;
public class TestLazyCharStream extends BaseTest {
@Test public void testNoChar() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("")
);
assertEquals(CharStream.EOF, input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void test1Char() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("x")
);
assertEquals('x', input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void test2Char() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("xy")
);
assertEquals('x', input.LA(1));
input.consume();
assertEquals('y', input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void test2CharAhead() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("xy")
);
assertEquals('x', input.LA(1));
assertEquals('y', input.LA(2));
assertEquals(CharStream.EOF, input.LA(3));
}
@Test public void testBufferExpand() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("01234"),
2 // buff size 2
);
assertEquals('0', input.LA(1));
assertEquals('1', input.LA(2));
assertEquals('2', input.LA(3));
assertEquals('3', input.LA(4));
assertEquals('4', input.LA(5));
assertEquals(CharStream.EOF, input.LA(6));
}
@Test public void testBufferWrapSize1() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("01234"),
1 // buff size 1
);
assertEquals('0', input.LA(1));
input.consume();
assertEquals('1', input.LA(1));
input.consume();
assertEquals('2', input.LA(1));
input.consume();
assertEquals('3', input.LA(1));
input.consume();
assertEquals('4', input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void testBufferWrapSize2() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("01234"),
2 // buff size 2
);
assertEquals('0', input.LA(1));
input.consume();
assertEquals('1', input.LA(1));
input.consume();
assertEquals('2', input.LA(1));
input.consume();
assertEquals('3', input.LA(1));
input.consume();
assertEquals('4', input.LA(1));
input.consume();
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void test1Mark() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("xyz")
);
int m = input.mark();
assertEquals('x', input.LA(1));
assertEquals('y', input.LA(2));
assertEquals('z', input.LA(3));
input.release(m);
assertEquals(CharStream.EOF, input.LA(4));
}
@Test public void test2Mark() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("xyz"),
2
);
assertEquals('x', input.LA(1));
input.consume();
int m1 = input.mark();
assertEquals('y', input.LA(1));
input.consume();
int m2 = input.mark();
assertEquals('z', input.LA(1));
input.release(m2); // noop since not earliest in buf
input.consume();
input.release(m1);
assertEquals(CharStream.EOF, input.LA(1));
}
@Test public void testLazy1CharAtTime() throws Exception {
CharStream input = new LazyCharStream(
new StringReader("x")
);
assertEquals(0, input.size());
assertEquals("x", input.getText(Interval.of(0,0)));
assertEquals(1, input.size());
input.consume(); // x already loaded so size is still 1 after this
input.consume(); // now we have x EOF
assertEquals(2, input.size());
assertEquals(CharStream.EOF, input.LA(1));
}
}