Remove old TokenRewriteStream in favor of new TokenStreamRewriter that is not a stream; it feeds off of the stream to provide transformations of that original stream. Updated the comment at the top of the file. Instead of toString() we use getText(). Altered the unit tests to create a buffered stream and then create the rewriter attached to that.
This commit is contained in:
Terence Parr
parent
3849cd572d
commit
bf9c7c3a28
|
|
@ -65,6 +65,8 @@ public interface TokenStream extends IntStream {
|
|||
*/
|
||||
public String getText(Interval interval);
|
||||
|
||||
public String getText();
|
||||
|
||||
public String getText(RuleContext ctx);
|
||||
|
||||
/** Because the user is not required to use a token with an index stored
|
||||
|
|
|
|||
|
|
@ -0,0 +1,562 @@
|
|||
package org.antlr.v4.runtime;
|
||||
|
||||
import org.antlr.v4.runtime.misc.Interval;
|
||||
import org.antlr.v4.runtime.misc.Nullable;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/** Useful for rewriting out a buffered input token stream after doing some
|
||||
* augmentation or other manipulations on it.
|
||||
*
|
||||
* You can insert stuff, replace, and delete chunks. Note that the
|
||||
* operations are done lazily--only if you convert the buffer to a
|
||||
* String with getText(). This is very efficient because you are not moving
|
||||
* data around all the time. As the buffer of tokens is converted to strings,
|
||||
* the getText() method(s) scan the input token stream and check
|
||||
* to see if there is an operation at the current index.
|
||||
* If so, the operation is done and then normal String
|
||||
* rendering continues on the buffer. This is like having multiple Turing
|
||||
* machine instruction streams (programs) operating on a single input tape. :)
|
||||
*
|
||||
* This rewriter makes no modifications to the token stream. It does not
|
||||
* ask the stream to fill itself up nor does it advance the input cursor.
|
||||
* The token stream index() will return the same value before and after
|
||||
* any getText() call.
|
||||
*
|
||||
* The rewriter only works on tokens that you have in the buffer and
|
||||
* ignores the current input cursor. If you are buffering tokens on-demand,
|
||||
* calling getText() halfway through the input will only do rewrites
|
||||
* for those tokens in the first half of the file.
|
||||
*
|
||||
* Since the operations are done lazily at getText-time, operations do not
|
||||
* screw up the token index values. That is, an insert operation at token
|
||||
* index i does not change the index values for tokens i+1..n-1.
|
||||
*
|
||||
* Because operations never actually alter the buffer, you may always get
|
||||
* the original token stream back without undoing anything. Since
|
||||
* the instructions are queued up, you can easily simulate transactions and
|
||||
* roll back any changes if there is an error just by removing instructions.
|
||||
* For example,
|
||||
*
|
||||
* CharStream input = new ANTLRFileStream("input");
|
||||
* TLexer lex = new TLexer(input);
|
||||
* CommonTokenStream tokens = new CommonTokenStream(lex);
|
||||
* T parser = new T(tokens);
|
||||
* TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
|
||||
* parser.startRule();
|
||||
*
|
||||
* Then in the rules, you can execute (assuming rewriter is visible):
|
||||
* Token t,u;
|
||||
* ...
|
||||
* rewriter.insertAfter(t, "text to put after t");}
|
||||
* rewriter.insertAfter(u, "text after u");}
|
||||
* System.out.println(tokens.toString());
|
||||
*
|
||||
* You can also have multiple "instruction streams" and get multiple
|
||||
* rewrites from a single pass over the input. Just name the instruction
|
||||
* streams and use that name again when printing the buffer. This could be
|
||||
* useful for generating a C file and also its header file--all from the
|
||||
* same buffer:
|
||||
*
|
||||
* tokens.insertAfter("pass1", t, "text to put after t");}
|
||||
* tokens.insertAfter("pass2", u, "text after u");}
|
||||
* System.out.println(tokens.toString("pass1"));
|
||||
* System.out.println(tokens.toString("pass2"));
|
||||
*
|
||||
* If you don't use named rewrite streams, a "default" stream is used as
|
||||
* the first example shows.
|
||||
*/
|
||||
public class TokenStreamRewriter {
|
||||
public static final String DEFAULT_PROGRAM_NAME = "default";
|
||||
public static final int PROGRAM_INIT_SIZE = 100;
|
||||
public static final int MIN_TOKEN_INDEX = 0;
|
||||
|
||||
// Define the rewrite operation hierarchy
|
||||
|
||||
public class RewriteOperation {
|
||||
/** What index into rewrites List are we? */
|
||||
protected int instructionIndex;
|
||||
/** Token buffer index. */
|
||||
protected int index;
|
||||
protected Object text;
|
||||
|
||||
protected RewriteOperation(int index) {
|
||||
this.index = index;
|
||||
}
|
||||
|
||||
protected RewriteOperation(int index, Object text) {
|
||||
this.index = index;
|
||||
this.text = text;
|
||||
}
|
||||
/** Execute the rewrite operation by possibly adding to the buffer.
|
||||
* Return the index of the next token to operate on.
|
||||
*/
|
||||
public int execute(StringBuilder buf) {
|
||||
return index;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
String opName = getClass().getName();
|
||||
int $index = opName.indexOf('$');
|
||||
opName = opName.substring($index+1, opName.length());
|
||||
return "<"+opName+"@"+tokens.get(index)+
|
||||
":\""+text+"\">";
|
||||
}
|
||||
}
|
||||
|
||||
class InsertBeforeOp extends RewriteOperation {
|
||||
public InsertBeforeOp(int index, Object text) {
|
||||
super(index,text);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int execute(StringBuilder buf) {
|
||||
buf.append(text);
|
||||
if ( tokens.get(index).getType()!=Token.EOF ) {
|
||||
buf.append(tokens.get(index).getText());
|
||||
}
|
||||
return index+1;
|
||||
}
|
||||
}
|
||||
|
||||
/** I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
|
||||
* instructions.
|
||||
*/
|
||||
class ReplaceOp extends RewriteOperation {
|
||||
protected int lastIndex;
|
||||
public ReplaceOp(int from, int to, Object text) {
|
||||
super(from,text);
|
||||
lastIndex = to;
|
||||
}
|
||||
@Override
|
||||
public int execute(StringBuilder buf) {
|
||||
if ( text!=null ) {
|
||||
buf.append(text);
|
||||
}
|
||||
return lastIndex+1;
|
||||
}
|
||||
@Override
|
||||
public String toString() {
|
||||
if ( text==null ) {
|
||||
return "<DeleteOp@"+tokens.get(index)+
|
||||
".."+tokens.get(lastIndex)+">";
|
||||
}
|
||||
return "<ReplaceOp@"+tokens.get(index)+
|
||||
".."+tokens.get(lastIndex)+":\""+text+"\">";
|
||||
}
|
||||
}
|
||||
|
||||
/** Our source stream */
|
||||
protected final BufferedTokenStream tokens;
|
||||
|
||||
/** You may have multiple, named streams of rewrite operations.
|
||||
* I'm calling these things "programs."
|
||||
* Maps String (name) -> rewrite (List)
|
||||
*/
|
||||
protected final Map<String, List<RewriteOperation>> programs;
|
||||
|
||||
/** Map String (program name) -> Integer index */
|
||||
protected final Map<String, Integer> lastRewriteTokenIndexes;
|
||||
|
||||
public TokenStreamRewriter(BufferedTokenStream tokens) {
|
||||
this.tokens = tokens;
|
||||
programs = new HashMap<String, List<RewriteOperation>>();
|
||||
programs.put(DEFAULT_PROGRAM_NAME,
|
||||
new ArrayList<RewriteOperation>(PROGRAM_INIT_SIZE));
|
||||
lastRewriteTokenIndexes = new HashMap<String, Integer>();
|
||||
}
|
||||
|
||||
public void rollback(int instructionIndex) {
|
||||
rollback(DEFAULT_PROGRAM_NAME, instructionIndex);
|
||||
}
|
||||
|
||||
/** Rollback the instruction stream for a program so that
|
||||
* the indicated instruction (via instructionIndex) is no
|
||||
* longer in the stream. UNTESTED!
|
||||
*/
|
||||
public void rollback(String programName, int instructionIndex) {
|
||||
List<RewriteOperation> is = programs.get(programName);
|
||||
if ( is!=null ) {
|
||||
programs.put(programName, is.subList(MIN_TOKEN_INDEX,instructionIndex));
|
||||
}
|
||||
}
|
||||
|
||||
public void deleteProgram() {
|
||||
deleteProgram(DEFAULT_PROGRAM_NAME);
|
||||
}
|
||||
|
||||
/** Reset the program so that no instructions exist */
|
||||
public void deleteProgram(String programName) {
|
||||
rollback(programName, MIN_TOKEN_INDEX);
|
||||
}
|
||||
|
||||
public void insertAfter(Token t, Object text) {
|
||||
insertAfter(DEFAULT_PROGRAM_NAME, t, text);
|
||||
}
|
||||
|
||||
public void insertAfter(int index, Object text) {
|
||||
insertAfter(DEFAULT_PROGRAM_NAME, index, text);
|
||||
}
|
||||
|
||||
public void insertAfter(String programName, Token t, Object text) {
|
||||
insertAfter(programName,t.getTokenIndex(), text);
|
||||
}
|
||||
|
||||
public void insertAfter(String programName, int index, Object text) {
|
||||
// to insert after, just insert before next index (even if past end)
|
||||
insertBefore(programName,index+1, text);
|
||||
}
|
||||
|
||||
public void insertBefore(Token t, Object text) {
|
||||
insertBefore(DEFAULT_PROGRAM_NAME, t, text);
|
||||
}
|
||||
|
||||
public void insertBefore(int index, Object text) {
|
||||
insertBefore(DEFAULT_PROGRAM_NAME, index, text);
|
||||
}
|
||||
|
||||
public void insertBefore(String programName, Token t, Object text) {
|
||||
insertBefore(programName, t.getTokenIndex(), text);
|
||||
}
|
||||
|
||||
public void insertBefore(String programName, int index, Object text) {
|
||||
RewriteOperation op = new InsertBeforeOp(index,text);
|
||||
List<RewriteOperation> rewrites = getProgram(programName);
|
||||
op.instructionIndex = rewrites.size();
|
||||
rewrites.add(op);
|
||||
}
|
||||
|
||||
public void replace(int index, Object text) {
|
||||
replace(DEFAULT_PROGRAM_NAME, index, index, text);
|
||||
}
|
||||
|
||||
public void replace(int from, int to, Object text) {
|
||||
replace(DEFAULT_PROGRAM_NAME, from, to, text);
|
||||
}
|
||||
|
||||
public void replace(Token indexT, Object text) {
|
||||
replace(DEFAULT_PROGRAM_NAME, indexT, indexT, text);
|
||||
}
|
||||
|
||||
public void replace(Token from, Token to, Object text) {
|
||||
replace(DEFAULT_PROGRAM_NAME, from, to, text);
|
||||
}
|
||||
|
||||
public void replace(String programName, int from, int to, @Nullable Object text) {
|
||||
if ( from > to || from<0 || to<0 || to >= tokens.size() ) {
|
||||
throw new IllegalArgumentException("replace: range invalid: "+from+".."+to+"(size="+tokens.size()+")");
|
||||
}
|
||||
RewriteOperation op = new ReplaceOp(from, to, text);
|
||||
List<RewriteOperation> rewrites = getProgram(programName);
|
||||
op.instructionIndex = rewrites.size();
|
||||
rewrites.add(op);
|
||||
}
|
||||
|
||||
public void replace(String programName, Token from, Token to, @Nullable Object text) {
|
||||
replace(programName,
|
||||
from.getTokenIndex(),
|
||||
to.getTokenIndex(),
|
||||
text);
|
||||
}
|
||||
|
||||
public void delete(int index) {
|
||||
delete(DEFAULT_PROGRAM_NAME, index, index);
|
||||
}
|
||||
|
||||
public void delete(int from, int to) {
|
||||
delete(DEFAULT_PROGRAM_NAME, from, to);
|
||||
}
|
||||
|
||||
public void delete(Token indexT) {
|
||||
delete(DEFAULT_PROGRAM_NAME, indexT, indexT);
|
||||
}
|
||||
|
||||
public void delete(Token from, Token to) {
|
||||
delete(DEFAULT_PROGRAM_NAME, from, to);
|
||||
}
|
||||
|
||||
public void delete(String programName, int from, int to) {
|
||||
replace(programName,from,to,null);
|
||||
}
|
||||
|
||||
public void delete(String programName, Token from, Token to) {
|
||||
replace(programName,from,to,null);
|
||||
}
|
||||
|
||||
public int getLastRewriteTokenIndex() {
|
||||
return getLastRewriteTokenIndex(DEFAULT_PROGRAM_NAME);
|
||||
}
|
||||
|
||||
protected int getLastRewriteTokenIndex(String programName) {
|
||||
Integer I = lastRewriteTokenIndexes.get(programName);
|
||||
if ( I==null ) {
|
||||
return -1;
|
||||
}
|
||||
return I;
|
||||
}
|
||||
|
||||
protected void setLastRewriteTokenIndex(String programName, int i) {
|
||||
lastRewriteTokenIndexes.put(programName, i);
|
||||
}
|
||||
|
||||
protected List<RewriteOperation> getProgram(String name) {
|
||||
List<RewriteOperation> is = programs.get(name);
|
||||
if ( is==null ) {
|
||||
is = initializeProgram(name);
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
private List<RewriteOperation> initializeProgram(String name) {
|
||||
List<RewriteOperation> is = new ArrayList<RewriteOperation>(PROGRAM_INIT_SIZE);
|
||||
programs.put(name, is);
|
||||
return is;
|
||||
}
|
||||
|
||||
public String getOriginalText() {
|
||||
return tokens.getText();
|
||||
}
|
||||
|
||||
/** The text collected from all tokens in the input token stream */
|
||||
public String getOriginalText(Interval interval) {
|
||||
return tokens.getText(interval);
|
||||
}
|
||||
|
||||
/** Return the text from the original tokens altered per the
|
||||
* instructions given to this rewriter.
|
||||
*/
|
||||
public String getText() {
|
||||
return getText(DEFAULT_PROGRAM_NAME, Interval.of(0,tokens.size()-1));
|
||||
}
|
||||
|
||||
/** Return the text associated with the tokens in the interval from the
|
||||
* original token stream but with the alterations given to this rewriter.
|
||||
* The interval refers to the indexes in the original token stream.
|
||||
* We do not alter the token stream in any way, so the indexes
|
||||
* and intervals are still consistent. Includes any operations done
|
||||
* to the first and last token in the interval. So, if you did an
|
||||
* insertBefore on the first token, you would get that insertion.
|
||||
* The same is true if you do an insertAfter the stop token.
|
||||
*/
|
||||
public String getText(Interval interval) {
|
||||
return getText(DEFAULT_PROGRAM_NAME, interval);
|
||||
}
|
||||
|
||||
public String getText(String programName, Interval interval) {
|
||||
List<RewriteOperation> rewrites = programs.get(programName);
|
||||
int start = interval.a;
|
||||
int stop = interval.b;
|
||||
|
||||
// ensure start/end are in range
|
||||
if ( stop>tokens.size()-1 ) stop = tokens.size()-1;
|
||||
if ( start<0 ) start = 0;
|
||||
|
||||
if ( rewrites==null || rewrites.isEmpty() ) {
|
||||
return tokens.getText(interval); // no instructions to execute
|
||||
}
|
||||
StringBuilder buf = new StringBuilder();
|
||||
|
||||
// First, optimize instruction stream
|
||||
Map<Integer, RewriteOperation> indexToOp = reduceToSingleOperationPerIndex(rewrites);
|
||||
|
||||
// Walk buffer, executing instructions and emitting tokens
|
||||
int i = start;
|
||||
while ( i <= stop && i < tokens.size() ) {
|
||||
RewriteOperation op = indexToOp.get(i);
|
||||
indexToOp.remove(i); // remove so any left have index size-1
|
||||
Token t = tokens.get(i);
|
||||
if ( op==null ) {
|
||||
// no operation at that index, just dump token
|
||||
if ( t.getType()!=Token.EOF ) buf.append(t.getText());
|
||||
i++; // move to next token
|
||||
}
|
||||
else {
|
||||
i = op.execute(buf); // execute operation and skip
|
||||
}
|
||||
}
|
||||
|
||||
// include stuff after end if it's last index in buffer
|
||||
// So, if they did an insertAfter(lastValidIndex, "foo"), include
|
||||
// foo if end==lastValidIndex.
|
||||
if ( stop==tokens.size()-1 ) {
|
||||
// Scan any remaining operations after last token
|
||||
// should be included (they will be inserts).
|
||||
for (RewriteOperation op : indexToOp.values()) {
|
||||
if ( op.index >= tokens.size()-1 ) buf.append(op.text);
|
||||
}
|
||||
}
|
||||
return buf.toString();
|
||||
}
|
||||
|
||||
/** We need to combine operations and report invalid operations (like
|
||||
* overlapping replaces that are not completed nested). Inserts to
|
||||
* same index need to be combined etc... Here are the cases:
|
||||
*
|
||||
* I.i.u I.j.v leave alone, nonoverlapping
|
||||
* I.i.u I.i.v combine: Iivu
|
||||
*
|
||||
* R.i-j.u R.x-y.v | i-j in x-y delete first R
|
||||
* R.i-j.u R.i-j.v delete first R
|
||||
* R.i-j.u R.x-y.v | x-y in i-j ERROR
|
||||
* R.i-j.u R.x-y.v | boundaries overlap ERROR
|
||||
*
|
||||
* Delete special case of replace (text==null):
|
||||
* D.i-j.u D.x-y.v | boundaries overlap combine to max(min)..max(right)
|
||||
*
|
||||
* I.i.u R.x-y.v | i in (x+1)-y delete I (since insert before
|
||||
* we're not deleting i)
|
||||
* I.i.u R.x-y.v | i not in (x+1)-y leave alone, nonoverlapping
|
||||
* R.x-y.v I.i.u | i in x-y ERROR
|
||||
* R.x-y.v I.x.u R.x-y.uv (combine, delete I)
|
||||
* R.x-y.v I.i.u | i not in x-y leave alone, nonoverlapping
|
||||
*
|
||||
* I.i.u = insert u before op @ index i
|
||||
* R.x-y.u = replace x-y indexed tokens with u
|
||||
*
|
||||
* First we need to examine replaces. For any replace op:
|
||||
*
|
||||
* 1. wipe out any insertions before op within that range.
|
||||
* 2. Drop any replace op before that is contained completely within
|
||||
* that range.
|
||||
* 3. Throw exception upon boundary overlap with any previous replace.
|
||||
*
|
||||
* Then we can deal with inserts:
|
||||
*
|
||||
* 1. for any inserts to same index, combine even if not adjacent.
|
||||
* 2. for any prior replace with same left boundary, combine this
|
||||
* insert with replace and delete this replace.
|
||||
* 3. throw exception if index in same range as previous replace
|
||||
*
|
||||
* Don't actually delete; make op null in list. Easier to walk list.
|
||||
* Later we can throw as we add to index -> op map.
|
||||
*
|
||||
* Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
|
||||
* inserted stuff would be before the replace range. But, if you
|
||||
* add tokens in front of a method body '{' and then delete the method
|
||||
* body, I think the stuff before the '{' you added should disappear too.
|
||||
*
|
||||
* Return a map from token index to operation.
|
||||
*/
|
||||
protected Map<Integer, RewriteOperation> reduceToSingleOperationPerIndex(List<RewriteOperation> rewrites) {
|
||||
// System.out.println("rewrites="+rewrites);
|
||||
|
||||
// WALK REPLACES
|
||||
for (int i = 0; i < rewrites.size(); i++) {
|
||||
RewriteOperation op = rewrites.get(i);
|
||||
if ( op==null ) continue;
|
||||
if ( !(op instanceof ReplaceOp) ) continue;
|
||||
ReplaceOp rop = (ReplaceOp)rewrites.get(i);
|
||||
// Wipe prior inserts within range
|
||||
List<? extends InsertBeforeOp> inserts = getKindOfOps(rewrites, InsertBeforeOp.class, i);
|
||||
for (InsertBeforeOp iop : inserts) {
|
||||
if ( iop.index == rop.index ) {
|
||||
// E.g., insert before 2, delete 2..2; update replace
|
||||
// text to include insert before, kill insert
|
||||
rewrites.set(iop.instructionIndex, null);
|
||||
rop.text = iop.text.toString() + (rop.text!=null?rop.text.toString():"");
|
||||
}
|
||||
else if ( iop.index > rop.index && iop.index <= rop.lastIndex ) {
|
||||
// delete insert as it's a no-op.
|
||||
rewrites.set(iop.instructionIndex, null);
|
||||
}
|
||||
}
|
||||
// Drop any prior replaces contained within
|
||||
List<? extends ReplaceOp> prevReplaces = getKindOfOps(rewrites, ReplaceOp.class, i);
|
||||
for (ReplaceOp prevRop : prevReplaces) {
|
||||
if ( prevRop.index>=rop.index && prevRop.lastIndex <= rop.lastIndex ) {
|
||||
// delete replace as it's a no-op.
|
||||
rewrites.set(prevRop.instructionIndex, null);
|
||||
continue;
|
||||
}
|
||||
// throw exception unless disjoint or identical
|
||||
boolean disjoint =
|
||||
prevRop.lastIndex<rop.index || prevRop.index > rop.lastIndex;
|
||||
boolean same =
|
||||
prevRop.index==rop.index && prevRop.lastIndex==rop.lastIndex;
|
||||
// Delete special case of replace (text==null):
|
||||
// D.i-j.u D.x-y.v | boundaries overlap combine to max(min)..max(right)
|
||||
if ( prevRop.text==null && rop.text==null && !disjoint ) {
|
||||
//System.out.println("overlapping deletes: "+prevRop+", "+rop);
|
||||
rewrites.set(prevRop.instructionIndex, null); // kill first delete
|
||||
rop.index = Math.min(prevRop.index, rop.index);
|
||||
rop.lastIndex = Math.max(prevRop.lastIndex, rop.lastIndex);
|
||||
System.out.println("new rop "+rop);
|
||||
}
|
||||
else if ( !disjoint && !same ) {
|
||||
throw new IllegalArgumentException("replace op boundaries of "+rop+
|
||||
" overlap with previous "+prevRop);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// WALK INSERTS
|
||||
for (int i = 0; i < rewrites.size(); i++) {
|
||||
RewriteOperation op = rewrites.get(i);
|
||||
if ( op==null ) continue;
|
||||
if ( !(op instanceof InsertBeforeOp) ) continue;
|
||||
InsertBeforeOp iop = (InsertBeforeOp)rewrites.get(i);
|
||||
// combine current insert with prior if any at same index
|
||||
List<? extends InsertBeforeOp> prevInserts = getKindOfOps(rewrites, InsertBeforeOp.class, i);
|
||||
for (InsertBeforeOp prevIop : prevInserts) {
|
||||
if ( prevIop.index == iop.index ) { // combine objects
|
||||
// convert to strings...we're in process of toString'ing
|
||||
// whole token buffer so no lazy eval issue with any templates
|
||||
iop.text = catOpText(iop.text,prevIop.text);
|
||||
// delete redundant prior insert
|
||||
rewrites.set(prevIop.instructionIndex, null);
|
||||
}
|
||||
}
|
||||
// look for replaces where iop.index is in range; error
|
||||
List<? extends ReplaceOp> prevReplaces = getKindOfOps(rewrites, ReplaceOp.class, i);
|
||||
for (ReplaceOp rop : prevReplaces) {
|
||||
if ( iop.index == rop.index ) {
|
||||
rop.text = catOpText(iop.text,rop.text);
|
||||
rewrites.set(i, null); // delete current insert
|
||||
continue;
|
||||
}
|
||||
if ( iop.index >= rop.index && iop.index <= rop.lastIndex ) {
|
||||
throw new IllegalArgumentException("insert op "+iop+
|
||||
" within boundaries of previous "+rop);
|
||||
}
|
||||
}
|
||||
}
|
||||
// System.out.println("rewrites after="+rewrites);
|
||||
Map<Integer, RewriteOperation> m = new HashMap<Integer, RewriteOperation>();
|
||||
for (int i = 0; i < rewrites.size(); i++) {
|
||||
RewriteOperation op = rewrites.get(i);
|
||||
if ( op==null ) continue; // ignore deleted ops
|
||||
if ( m.get(op.index)!=null ) {
|
||||
throw new Error("should only be one op per index");
|
||||
}
|
||||
m.put(op.index, op);
|
||||
}
|
||||
//System.out.println("index to op: "+m);
|
||||
return m;
|
||||
}
|
||||
|
||||
protected String catOpText(Object a, Object b) {
|
||||
String x = "";
|
||||
String y = "";
|
||||
if ( a!=null ) x = a.toString();
|
||||
if ( b!=null ) y = b.toString();
|
||||
return x+y;
|
||||
}
|
||||
|
||||
/** Get all operations before an index of a particular kind */
|
||||
protected <T extends RewriteOperation> List<? extends T> getKindOfOps(List<? extends RewriteOperation> rewrites, Class<T> kind, int before) {
|
||||
List<T> ops = new ArrayList<T>();
|
||||
for (int i=0; i<before && i<rewrites.size(); i++) {
|
||||
RewriteOperation op = rewrites.get(i);
|
||||
if ( op==null ) continue; // ignore deleted
|
||||
if ( kind.isInstance(op) ) {
|
||||
ops.add((T)op);
|
||||
}
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -98,6 +98,11 @@ public class UnbufferedTokenStream<T extends Token>
|
|||
return buf.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getText() {
|
||||
return getText(Interval.of(0,index()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getText(RuleContext ctx) {
|
||||
return getText(ctx.getSourceInterval());
|
||||
|
|
|
|||
|
|
@ -1097,6 +1097,11 @@ public abstract class BaseTest {
|
|||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getText() {
|
||||
throw new UnsupportedOperationException("can't give strings");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getText(Interval interval) {
|
||||
throw new UnsupportedOperationException("can't give strings");
|
||||
|
|
|
|||
|
|
@ -1,807 +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.test;
|
||||
|
||||
import org.antlr.v4.runtime.TokenRewriteStream;
|
||||
import org.antlr.v4.runtime.misc.Interval;
|
||||
import org.antlr.v4.tool.LexerGrammar;
|
||||
import org.antlr.v4.tool.interp.LexerInterpreter;
|
||||
import org.junit.Test;
|
||||
|
||||
public class TestTokenRewriteStream extends BaseTest {
|
||||
|
||||
/** Public default constructor used by TestRig */
|
||||
public TestTokenRewriteStream() {
|
||||
}
|
||||
|
||||
@Test public void testInsertBeforeIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
LexerInterpreter lexInterp = new LexerInterpreter(g, "abc");
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexInterp);
|
||||
tokens.insertBefore(0, "0");
|
||||
String result = tokens.toString();
|
||||
String expecting = "0abc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertAfterLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.insertAfter(2, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abcx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertBeforeAfterMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertAfter(1, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "axbxc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(0, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "xbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "axc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testToStringStartStop() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"ID : 'a'..'z'+;\n" +
|
||||
"INT : '0'..'9'+;\n" +
|
||||
"SEMI : ';';\n" +
|
||||
"MUL : '*';\n" +
|
||||
"ASSIGN : '=';\n" +
|
||||
"WS : ' '+;\n");
|
||||
// Tokens: 0123456789
|
||||
// Input: x = 3 * 0;
|
||||
String input = "x = 3 * 0;";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(4, 8, "0"); // replace 3 * 0 with 0
|
||||
|
||||
String result = tokens.toOriginalString();
|
||||
String expecting = "x = 3 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.toString();
|
||||
expecting = "x = 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 9));
|
||||
expecting = "x = 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(4, 8));
|
||||
expecting = "0";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testToStringStartStop2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"ID : 'a'..'z'+;\n" +
|
||||
"INT : '0'..'9'+;\n" +
|
||||
"SEMI : ';';\n" +
|
||||
"ASSIGN : '=';\n" +
|
||||
"PLUS : '+';\n" +
|
||||
"MULT : '*';\n" +
|
||||
"WS : ' '+;\n");
|
||||
// Tokens: 012345678901234567
|
||||
// Input: x = 3 * 0 + 2 * 0;
|
||||
String input = "x = 3 * 0 + 2 * 0;";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
|
||||
String result = tokens.toOriginalString();
|
||||
String expecting = "x = 3 * 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
tokens.replace(4, 8, "0"); // replace 3 * 0 with 0
|
||||
result = tokens.toString();
|
||||
expecting = "x = 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 17));
|
||||
expecting = "x = 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(4, 8));
|
||||
expecting = "0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 8));
|
||||
expecting = "x = 0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(12, 16));
|
||||
expecting = "2 * 0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
tokens.insertAfter(17, "// comment");
|
||||
result = tokens.getText(Interval.of(12, 18));
|
||||
expecting = "2 * 0;// comment";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 8)); // try again after insert at end
|
||||
expecting = "x = 0";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
|
||||
@Test public void test2ReplaceMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, "x");
|
||||
tokens.replace(1, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "ayc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2ReplaceMiddleIndex1InsertBefore() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(0, "_");
|
||||
tokens.replace(1, "x");
|
||||
tokens.replace(1, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "_ayc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenDeleteMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, "x");
|
||||
tokens.delete(1);
|
||||
String result = tokens.toString();
|
||||
String expecting = "ac";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertInPriorReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(0, 2, "x");
|
||||
tokens.insertBefore(1, "0");
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.toString();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "insert op <InsertBeforeOp@[@1,1:1='b',<4>,1:1]:\"0\"> within boundaries of previous <ReplaceOp@[@0,0:0='a',<3>,1:0]..[@2,2:2='c',<5>,1:2]:\"x\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testInsertThenReplaceSameIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(0, "0");
|
||||
tokens.replace(0, "x"); // supercedes insert at 0
|
||||
String result = tokens.toString();
|
||||
String expecting = "0xbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(1, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "ayxbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertThenReplaceIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(0, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
tokens.replace(0, "z");
|
||||
String result = tokens.toString();
|
||||
String expecting = "yxzbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenInsertBeforeLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abyx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertThenReplaceLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.replace(2, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abyx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenInsertAfterLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, "x");
|
||||
tokens.insertAfter(2, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abxy";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAtLeftEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abyxba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAtRightEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertBefore(4, "y"); // no effect; within range of a replace
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.toString();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "insert op <InsertBeforeOp@[@4,4:4='c',<5>,1:4]:\"y\"> within boundaries of previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"x\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAfterRightEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertAfter(4, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "abxyba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceAll() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(0, 6, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "x";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceSubsetThenFetch() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "xyz");
|
||||
String result = tokens.getText(Interval.of(0, 6));
|
||||
String expecting = "abxyzba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenReplaceSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "xyz");
|
||||
tokens.replace(3, 5, "foo"); // overlaps, error
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.toString();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@3,3:3='c',<5>,1:3]..[@5,5:5='b',<4>,1:5]:\"foo\"> overlap with previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"xyz\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenReplaceLowerIndexedSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 4, "xyz");
|
||||
tokens.replace(1, 3, "foo"); // overlap, error
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.toString();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@1,1:1='b',<4>,1:1]..[@3,3:3='c',<5>,1:3]:\"foo\"> overlap with previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"xyz\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceSingleMiddleThenOverlappingSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 2, "xyz");
|
||||
tokens.replace(0, 3, "foo");
|
||||
String result = tokens.toString();
|
||||
String expecting = "fooa";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
// June 2, 2008 I rewrote core of rewrite engine; just adding lots more tests here
|
||||
|
||||
@Test public void testCombineInserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(0, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
String result = tokens.toString();
|
||||
String expecting = "yxabc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombine3Inserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
tokens.insertBefore(1, "z");
|
||||
String result = tokens.toString();
|
||||
String expecting = "yazxbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombineInsertOnLeftWithReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(0, 2, "foo");
|
||||
tokens.insertBefore(0, "z"); // combine with left edge of rewrite
|
||||
String result = tokens.toString();
|
||||
String expecting = "zfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombineInsertOnLeftWithDelete() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.delete(0, 2);
|
||||
tokens.insertBefore(0, "z"); // combine with left edge of rewrite
|
||||
String result = tokens.toString();
|
||||
String expecting = "z"; // make sure combo is not znull
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDisjointInserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.insertBefore(0, "z");
|
||||
String result = tokens.toString();
|
||||
String expecting = "zaxbyc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(0, 3, "bar"); // wipes prior nested replace
|
||||
String result = tokens.toString();
|
||||
String expecting = "bar";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(0, 3, "bar");
|
||||
tokens.replace(1, 2, "foo"); // cannot split earlier replace
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.toString();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@1,1:1='b',<4>,1:1]..[@2,2:2='c',<5>,1:2]:\"foo\"> overlap with previous <ReplaceOp@[@0,0:0='a',<3>,1:0]..[@3,3:3='c',<5>,1:3]:\"bar\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace3() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(0, 2, "bar"); // wipes prior nested replace
|
||||
String result = tokens.toString();
|
||||
String expecting = "barc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace4() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(1, 3, "bar"); // wipes prior nested replace
|
||||
String result = tokens.toString();
|
||||
String expecting = "abar";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDropIdenticalReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(1, 2, "foo"); // drop previous, identical
|
||||
String result = tokens.toString();
|
||||
String expecting = "afooc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDropPrevCoveredInsert() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "foo");
|
||||
tokens.replace(1, 2, "foo"); // kill prev insert
|
||||
String result = tokens.toString();
|
||||
String expecting = "afoofoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testLeaveAloneDisjointInsert() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.replace(2, 3, "foo");
|
||||
String result = tokens.toString();
|
||||
String expecting = "axbfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testLeaveAloneDisjointInsert2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.replace(2, 3, "foo");
|
||||
tokens.insertBefore(1, "x");
|
||||
String result = tokens.toString();
|
||||
String expecting = "axbfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertBeforeTokenThenDeleteThatToken() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
TokenRewriteStream tokens = new TokenRewriteStream(lexEngine);
|
||||
tokens.fill();
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.delete(2);
|
||||
String result = tokens.toString();
|
||||
String expecting = "aby";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,879 @@
|
|||
/*
|
||||
[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.test;
|
||||
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
import org.antlr.v4.runtime.TokenStreamRewriter;
|
||||
import org.antlr.v4.runtime.misc.Interval;
|
||||
import org.antlr.v4.tool.LexerGrammar;
|
||||
import org.antlr.v4.tool.interp.LexerInterpreter;
|
||||
import org.junit.Test;
|
||||
|
||||
public class TestTokenStreamRewriter extends BaseTest {
|
||||
|
||||
/** Public default constructor used by TestRig */
|
||||
public TestTokenStreamRewriter() {
|
||||
}
|
||||
|
||||
@Test public void testInsertBeforeIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, "abc");
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(0, "0");
|
||||
String result = tokens.getText();
|
||||
String expecting = "0abc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertAfterLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertAfter(2, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abcx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertBeforeAfterMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertAfter(1, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "axbxc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(0, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "xbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "axc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testToStringStartStop() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"ID : 'a'..'z'+;\n" +
|
||||
"INT : '0'..'9'+;\n" +
|
||||
"SEMI : ';';\n" +
|
||||
"MUL : '*';\n" +
|
||||
"ASSIGN : '=';\n" +
|
||||
"WS : ' '+;\n");
|
||||
// Tokens: 0123456789
|
||||
// Input: x = 3 * 0;
|
||||
String input = "x = 3 * 0;";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(4, 8, "0");
|
||||
stream.fill();
|
||||
// replace 3 * 0 with 0
|
||||
|
||||
String result = tokens.getOriginalText();
|
||||
String expecting = "x = 3 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText();
|
||||
expecting = "x = 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 9));
|
||||
expecting = "x = 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(4, 8));
|
||||
expecting = "0";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testToStringStartStop2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"ID : 'a'..'z'+;\n" +
|
||||
"INT : '0'..'9'+;\n" +
|
||||
"SEMI : ';';\n" +
|
||||
"ASSIGN : '=';\n" +
|
||||
"PLUS : '+';\n" +
|
||||
"MULT : '*';\n" +
|
||||
"WS : ' '+;\n");
|
||||
// Tokens: 012345678901234567
|
||||
// Input: x = 3 * 0 + 2 * 0;
|
||||
String input = "x = 3 * 0 + 2 * 0;";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
|
||||
String result = tokens.getOriginalText();
|
||||
String expecting = "x = 3 * 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
tokens.replace(4, 8, "0");
|
||||
stream.fill();
|
||||
// replace 3 * 0 with 0
|
||||
result = tokens.getText();
|
||||
expecting = "x = 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 17));
|
||||
expecting = "x = 0 + 2 * 0;";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(4, 8));
|
||||
expecting = "0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 8));
|
||||
expecting = "x = 0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(12, 16));
|
||||
expecting = "2 * 0";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
tokens.insertAfter(17, "// comment");
|
||||
result = tokens.getText(Interval.of(12, 18));
|
||||
expecting = "2 * 0;// comment";
|
||||
assertEquals(expecting, result);
|
||||
|
||||
result = tokens.getText(Interval.of(0, 8));
|
||||
stream.fill();
|
||||
// try again after insert at end
|
||||
expecting = "x = 0";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
|
||||
@Test public void test2ReplaceMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, "x");
|
||||
tokens.replace(1, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "ayc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2ReplaceMiddleIndex1InsertBefore() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(0, "_");
|
||||
tokens.replace(1, "x");
|
||||
tokens.replace(1, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "_ayc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenDeleteMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, "x");
|
||||
tokens.delete(1);
|
||||
String result = tokens.getText();
|
||||
String expecting = "ac";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertInPriorReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(0, 2, "x");
|
||||
tokens.insertBefore(1, "0");
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.getText();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "insert op <InsertBeforeOp@[@1,1:1='b',<4>,1:1]:\"0\"> within boundaries of previous <ReplaceOp@[@0,0:0='a',<3>,1:0]..[@2,2:2='c',<5>,1:2]:\"x\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testInsertThenReplaceSameIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(0, "0");
|
||||
tokens.replace(0, "x");
|
||||
stream.fill();
|
||||
// supercedes insert at 0
|
||||
String result = tokens.getText();
|
||||
String expecting = "0xbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertMiddleIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(1, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "ayxbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void test2InsertThenReplaceIndex0() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(0, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
tokens.replace(0, "z");
|
||||
String result = tokens.getText();
|
||||
String expecting = "yxzbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenInsertBeforeLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abyx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertThenReplaceLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.replace(2, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abyx";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenInsertAfterLastIndex() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, "x");
|
||||
tokens.insertAfter(2, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abxy";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAtLeftEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abyxba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAtRightEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertBefore(4, "y");
|
||||
stream.fill(); // no effect; within range of a replace
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.getText();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "insert op <InsertBeforeOp@[@4,4:4='c',<5>,1:4]:\"y\"> within boundaries of previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"x\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceRangeThenInsertAfterRightEdge() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "x");
|
||||
tokens.insertAfter(4, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "abxyba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceAll() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(0, 6, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "x";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceSubsetThenFetch() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "xyz");
|
||||
String result = tokens.getText(Interval.of(0, 6));
|
||||
String expecting = "abxyzba";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenReplaceSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "xyz");
|
||||
tokens.replace(3, 5, "foo");
|
||||
stream.fill();
|
||||
// overlaps, error
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.getText();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@3,3:3='c',<5>,1:3]..[@5,5:5='b',<4>,1:5]:\"foo\"> overlap with previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"xyz\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceThenReplaceLowerIndexedSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcccba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 4, "xyz");
|
||||
tokens.replace(1, 3, "foo");
|
||||
stream.fill();
|
||||
// overlap, error
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.getText();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@1,1:1='b',<4>,1:1]..[@3,3:3='c',<5>,1:3]:\"foo\"> overlap with previous <ReplaceOp@[@2,2:2='c',<5>,1:2]..[@4,4:4='c',<5>,1:4]:\"xyz\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testReplaceSingleMiddleThenOverlappingSuperset() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcba";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 2, "xyz");
|
||||
tokens.replace(0, 3, "foo");
|
||||
String result = tokens.getText();
|
||||
String expecting = "fooa";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombineInserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(0, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
String result = tokens.getText();
|
||||
String expecting = "yxabc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombine3Inserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(0, "y");
|
||||
tokens.insertBefore(1, "z");
|
||||
String result = tokens.getText();
|
||||
String expecting = "yazxbc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombineInsertOnLeftWithReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(0, 2, "foo");
|
||||
tokens.insertBefore(0, "z");
|
||||
stream.fill();
|
||||
// combine with left edge of rewrite
|
||||
String result = tokens.getText();
|
||||
String expecting = "zfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testCombineInsertOnLeftWithDelete() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.delete(0, 2);
|
||||
tokens.insertBefore(0, "z");
|
||||
stream.fill();
|
||||
// combine with left edge of rewrite
|
||||
String result = tokens.getText();
|
||||
String expecting = "z";
|
||||
stream.fill();
|
||||
// make sure combo is not znull
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDisjointInserts() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.insertBefore(0, "z");
|
||||
String result = tokens.getText();
|
||||
String expecting = "zaxbyc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(0, 3, "bar");
|
||||
stream.fill();
|
||||
// wipes prior nested replace
|
||||
String result = tokens.getText();
|
||||
String expecting = "bar";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(0, 3, "bar");
|
||||
tokens.replace(1, 2, "foo");
|
||||
stream.fill();
|
||||
// cannot split earlier replace
|
||||
Exception exc = null;
|
||||
try {
|
||||
tokens.getText();
|
||||
}
|
||||
catch (IllegalArgumentException iae) {
|
||||
exc = iae;
|
||||
}
|
||||
String expecting = "replace op boundaries of <ReplaceOp@[@1,1:1='b',<4>,1:1]..[@2,2:2='c',<5>,1:2]:\"foo\"> overlap with previous <ReplaceOp@[@0,0:0='a',<3>,1:0]..[@3,3:3='c',<5>,1:3]:\"bar\">";
|
||||
assertNotNull(exc);
|
||||
assertEquals(expecting, exc.getMessage());
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace3() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(0, 2, "bar");
|
||||
stream.fill();
|
||||
// wipes prior nested replace
|
||||
String result = tokens.getText();
|
||||
String expecting = "barc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testOverlappingReplace4() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(1, 3, "bar");
|
||||
stream.fill();
|
||||
// wipes prior nested replace
|
||||
String result = tokens.getText();
|
||||
String expecting = "abar";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDropIdenticalReplace() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(1, 2, "foo");
|
||||
tokens.replace(1, 2, "foo");
|
||||
stream.fill();
|
||||
// drop previous, identical
|
||||
String result = tokens.getText();
|
||||
String expecting = "afooc";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testDropPrevCoveredInsert() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "foo");
|
||||
tokens.replace(1, 2, "foo");
|
||||
stream.fill();
|
||||
// kill prev insert
|
||||
String result = tokens.getText();
|
||||
String expecting = "afoofoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testLeaveAloneDisjointInsert() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(1, "x");
|
||||
tokens.replace(2, 3, "foo");
|
||||
String result = tokens.getText();
|
||||
String expecting = "axbfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testLeaveAloneDisjointInsert2() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abcc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.replace(2, 3, "foo");
|
||||
tokens.insertBefore(1, "x");
|
||||
String result = tokens.getText();
|
||||
String expecting = "axbfoo";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
@Test public void testInsertBeforeTokenThenDeleteThatToken() throws Exception {
|
||||
LexerGrammar g = new LexerGrammar(
|
||||
"lexer grammar t;\n"+
|
||||
"A : 'a';\n" +
|
||||
"B : 'b';\n" +
|
||||
"C : 'c';\n");
|
||||
String input = "abc";
|
||||
LexerInterpreter lexEngine = new LexerInterpreter(g, input);
|
||||
CommonTokenStream stream = new CommonTokenStream(lexEngine);
|
||||
stream.fill();
|
||||
TokenStreamRewriter tokens = new TokenStreamRewriter(stream);
|
||||
tokens.insertBefore(2, "y");
|
||||
tokens.delete(2);
|
||||
String result = tokens.getText();
|
||||
String expecting = "aby";
|
||||
assertEquals(expecting, result);
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue