/*
* [The "BSD licence"]
* Copyright (c) 2005-2008 Terence Parr
* All rights reserved.
*
* Conversion to C#:
* Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
* 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.
*/
namespace Antlr.Runtime
{
using System.Collections.Generic;
using ArgumentException = System.ArgumentException;
using Console = System.Console;
using Math = System.Math;
using DebuggerDisplay = System.Diagnostics.DebuggerDisplayAttribute;
using Exception = System.Exception;
using StringBuilder = System.Text.StringBuilder;
using Type = System.Type;
/** Useful for dumping out the input stream after doing some
* augmentation or other manipulations.
*
* You can insert stuff, replace, and delete chunks. Note that the
* operations are done lazily--only if you convert the buffer to a
* String. This is very efficient because you are not moving data around
* all the time. As the buffer of tokens is converted to strings, the
* toString() method(s) 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. :)
*
* Since the operations are done lazily at toString-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);
* TokenRewriteStream tokens = new TokenRewriteStream(lex);
* T parser = new T(tokens);
* parser.startRule();
*
* Then in the rules, you can execute
* Token t,u;
* ...
* input.insertAfter(t, "text to put after t");}
* input.insertAfter(u, "text after u");}
* System.out.println(tokens.toString());
*
* Actually, you have to cast the 'input' to a TokenRewriteStream. :(
*
* 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.
*/
[System.Serializable]
[DebuggerDisplay( "TODO: TokenRewriteStream debugger display" )]
public class TokenRewriteStream : CommonTokenStream
{
public const string DEFAULT_PROGRAM_NAME = "default";
public const int PROGRAM_INIT_SIZE = 100;
public const int MIN_TOKEN_INDEX = 0;
// Define the rewrite operation hierarchy
protected class RewriteOperation
{
/** <summary>What index into rewrites List are we?</summary> */
public int instructionIndex;
/** <summary>Token buffer index.</summary> */
public int index;
public object text;
// outer
protected TokenRewriteStream stream;
protected RewriteOperation(TokenRewriteStream stream, int index)
{
this.stream = stream;
this.index = index;
}
protected RewriteOperation( TokenRewriteStream stream, int index, object text )
{
this.index = index;
this.text = text;
this.stream = stream;
}
/** <summary>
* Execute the rewrite operation by possibly adding to the buffer.
* Return the index of the next token to operate on.
* </summary>
*/
public virtual int Execute( StringBuilder buf )
{
return index;
}
public override string ToString()
{
string opName = this.GetType().Name;
int dindex = opName.IndexOf( '$' );
opName = opName.Substring( dindex + 1 );
return string.Format("<{0}@{1}:\"{2}\">", opName, stream._tokens[index], text);
}
}
private class InsertBeforeOp : RewriteOperation
{
public InsertBeforeOp( TokenRewriteStream stream, int index, object text ) :
base( stream, index, text )
{
}
public override int Execute( StringBuilder buf )
{
buf.Append( text );
if (stream._tokens[index].Type != CharStreamConstants.EndOfFile)
buf.Append(stream._tokens[index].Text);
return index + 1;
}
}
/** <summary>
* I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
* instructions.
* </summary>
*/
private class ReplaceOp : RewriteOperation
{
public int lastIndex;
public ReplaceOp( TokenRewriteStream stream, int from, int to, object text )
: base( stream, from, text )
{
lastIndex = to;
}
public override int Execute( StringBuilder buf )
{
if ( text != null )
{
buf.Append( text );
}
return lastIndex + 1;
}
public override string ToString()
{
if (text == null)
{
return string.Format("<DeleteOp@{0}..{1}>", stream._tokens[index], stream._tokens[lastIndex]);
}
return string.Format("<ReplaceOp@{0}..{1}:\"{2}\">", stream._tokens[index], stream._tokens[lastIndex], text);
}
}
/** <summary>
* You may have multiple, named streams of rewrite operations.
* I'm calling these things "programs."
* Maps String (name) -> rewrite (List)
* </summary>
*/
protected IDictionary<string, IList<RewriteOperation>> programs = null;
/** <summary>Map String (program name) -> Integer index</summary> */
protected IDictionary<string, int> lastRewriteTokenIndexes = null;
public TokenRewriteStream()
{
Init();
}
protected void Init()
{
programs = new Dictionary<string, IList<RewriteOperation>>();
programs[DEFAULT_PROGRAM_NAME] = new List<RewriteOperation>( PROGRAM_INIT_SIZE );
lastRewriteTokenIndexes = new Dictionary<string, int>();
}
public TokenRewriteStream( ITokenSource tokenSource )
: base( tokenSource )
{
Init();
}
public TokenRewriteStream( ITokenSource tokenSource, int channel )
: base( tokenSource, channel )
{
Init();
}
public virtual void Rollback( int instructionIndex )
{
Rollback( DEFAULT_PROGRAM_NAME, instructionIndex );
}
/** <summary>
* Rollback the instruction stream for a program so that
* the indicated instruction (via instructionIndex) is no
* longer in the stream. UNTESTED!
* </summary>
*/
public virtual void Rollback( string programName, int instructionIndex )
{
IList<RewriteOperation> @is;
if ( programs.TryGetValue( programName, out @is ) && @is != null )
{
List<RewriteOperation> sublist = new List<RewriteOperation>();
for ( int i = MIN_TOKEN_INDEX; i <= instructionIndex; i++ )
sublist.Add( @is[i] );
programs[programName] = sublist;
}
}
public virtual void DeleteProgram()
{
DeleteProgram( DEFAULT_PROGRAM_NAME );
}
/** <summary>Reset the program so that no instructions exist</summary> */
public virtual void DeleteProgram( string programName )
{
Rollback( programName, MIN_TOKEN_INDEX );
}
public virtual void InsertAfter( IToken t, object text )
{
InsertAfter( DEFAULT_PROGRAM_NAME, t, text );
}
public virtual void InsertAfter( int index, object text )
{
InsertAfter( DEFAULT_PROGRAM_NAME, index, text );
}
public virtual void InsertAfter( string programName, IToken t, object text )
{
InsertAfter( programName, t.TokenIndex, text );
}
public virtual 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 virtual void InsertBefore( IToken t, object text )
{
InsertBefore( DEFAULT_PROGRAM_NAME, t, text );
}
public virtual void InsertBefore( int index, object text )
{
InsertBefore( DEFAULT_PROGRAM_NAME, index, text );
}
public virtual void InsertBefore( string programName, IToken t, object text )
{
InsertBefore( programName, t.TokenIndex, text );
}
public virtual void InsertBefore( string programName, int index, object text )
{
RewriteOperation op = new InsertBeforeOp( this, index, text );
IList<RewriteOperation> rewrites = GetProgram( programName );
op.instructionIndex = rewrites.Count;
rewrites.Add( op );
}
public virtual void Replace( int index, object text )
{
Replace( DEFAULT_PROGRAM_NAME, index, index, text );
}
public virtual void Replace( int from, int to, object text )
{
Replace( DEFAULT_PROGRAM_NAME, from, to, text );
}
public virtual void Replace( IToken indexT, object text )
{
Replace( DEFAULT_PROGRAM_NAME, indexT, indexT, text );
}
public virtual void Replace( IToken from, IToken to, object text )
{
Replace( DEFAULT_PROGRAM_NAME, from, to, text );
}
public virtual void Replace( string programName, int from, int to, object text )
{
if ( from > to || from < 0 || to < 0 || to >= _tokens.Count )
{
throw new ArgumentException( "replace: range invalid: " + from + ".." + to + "(size=" + _tokens.Count + ")" );
}
RewriteOperation op = new ReplaceOp( this, from, to, text );
IList<RewriteOperation> rewrites = GetProgram( programName );
op.instructionIndex = rewrites.Count;
rewrites.Add( op );
}
public virtual void Replace( string programName, IToken from, IToken to, object text )
{
Replace( programName,
from.TokenIndex,
to.TokenIndex,
text );
}
public virtual void Delete( int index )
{
Delete( DEFAULT_PROGRAM_NAME, index, index );
}
public virtual void Delete( int from, int to )
{
Delete( DEFAULT_PROGRAM_NAME, from, to );
}
public virtual void Delete( IToken indexT )
{
Delete( DEFAULT_PROGRAM_NAME, indexT, indexT );
}
public virtual void Delete( IToken from, IToken to )
{
Delete( DEFAULT_PROGRAM_NAME, from, to );
}
public virtual void Delete( string programName, int from, int to )
{
Replace( programName, from, to, null );
}
public virtual void Delete( string programName, IToken from, IToken to )
{
Replace( programName, from, to, null );
}
public virtual int GetLastRewriteTokenIndex()
{
return GetLastRewriteTokenIndex( DEFAULT_PROGRAM_NAME );
}
protected virtual int GetLastRewriteTokenIndex( string programName )
{
int value;
if ( lastRewriteTokenIndexes.TryGetValue( programName, out value ) )
return value;
return -1;
}
protected virtual void SetLastRewriteTokenIndex( string programName, int i )
{
lastRewriteTokenIndexes[programName] = i;
}
protected virtual IList<RewriteOperation> GetProgram( string name )
{
IList<RewriteOperation> @is;
if ( !programs.TryGetValue( name, out @is ) || @is == null )
{
@is = InitializeProgram( name );
}
return @is;
}
private IList<RewriteOperation> InitializeProgram( string name )
{
IList<RewriteOperation> @is = new List<RewriteOperation>( PROGRAM_INIT_SIZE );
programs[name] = @is;
return @is;
}
public virtual string ToOriginalString()
{
Fill();
return ToOriginalString( MIN_TOKEN_INDEX, Count - 1 );
}
public virtual string ToOriginalString( int start, int end )
{
StringBuilder buf = new StringBuilder();
for ( int i = start; i >= MIN_TOKEN_INDEX && i <= end && i < _tokens.Count; i++ )
{
if (Get(i).Type != CharStreamConstants.EndOfFile)
buf.Append(Get(i).Text);
}
return buf.ToString();
}
public override string ToString()
{
Fill();
return ToString( MIN_TOKEN_INDEX, Count - 1 );
}
public virtual string ToString( string programName )
{
Fill();
return ToString(programName, MIN_TOKEN_INDEX, Count - 1);
}
public override string ToString( int start, int end )
{
return ToString( DEFAULT_PROGRAM_NAME, start, end );
}
public virtual string ToString( string programName, int start, int end )
{
IList<RewriteOperation> rewrites;
if ( !programs.TryGetValue( programName, out rewrites ) )
rewrites = null;
// ensure start/end are in range
if ( end > _tokens.Count - 1 )
end = _tokens.Count - 1;
if ( start < 0 )
start = 0;
if ( rewrites == null || rewrites.Count == 0 )
{
return ToOriginalString( start, end ); // no instructions to execute
}
StringBuilder buf = new StringBuilder();
// First, optimize instruction stream
IDictionary<int, RewriteOperation> indexToOp = ReduceToSingleOperationPerIndex( rewrites );
// Walk buffer, executing instructions and emitting tokens
int i = start;
while ( i <= end && i < _tokens.Count )
{
RewriteOperation op;
bool exists = indexToOp.TryGetValue( i, out op );
if ( exists )
{
// remove so any left have index size-1
indexToOp.Remove( i );
}
if ( !exists || op == null )
{
IToken t = _tokens[i];
// no operation at that index, just dump token
if (t.Type != CharStreamConstants.EndOfFile)
buf.Append(t.Text);
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 ( end == _tokens.Count - 1 )
{
// Scan any remaining operations after last token
// should be included (they will be inserts).
foreach ( RewriteOperation op in indexToOp.Values )
{
if ( op.index >= _tokens.Count - 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 virtual IDictionary<int, RewriteOperation> ReduceToSingleOperationPerIndex( IList<RewriteOperation> rewrites )
{
//System.out.println("rewrites="+rewrites);
// WALK REPLACES
for ( int i = 0; i < rewrites.Count; i++ )
{
RewriteOperation op = rewrites[i];
if ( op == null )
continue;
if ( !( op is ReplaceOp ) )
continue;
ReplaceOp rop = (ReplaceOp)rewrites[i];
// Wipe prior inserts within range
var inserts = GetKindOfOps( rewrites, typeof( InsertBeforeOp ), i );
for ( int j = 0; j < inserts.Count; j++ )
{
InsertBeforeOp iop = (InsertBeforeOp)inserts[j];
if (iop.index == rop.index)
{
// E.g., insert before 2, delete 2..2; update replace
// text to include insert before, kill insert
rewrites[iop.instructionIndex] = null;
rop.text = iop.text.ToString() + (rop.text != null ? rop.text.ToString() : string.Empty);
}
else if (iop.index > rop.index && iop.index <= rop.lastIndex)
{
// delete insert as it's a no-op.
rewrites[iop.instructionIndex] = null;
}
}
// Drop any prior replaces contained within
var prevReplaces = GetKindOfOps( rewrites, typeof( ReplaceOp ), i );
for ( int j = 0; j < prevReplaces.Count; j++ )
{
ReplaceOp prevRop = (ReplaceOp)prevReplaces[j];
if ( prevRop.index >= rop.index && prevRop.lastIndex <= rop.lastIndex )
{
// delete replace as it's a no-op.
rewrites[prevRop.instructionIndex] = null;
continue;
}
// throw exception unless disjoint or identical
bool disjoint =
prevRop.lastIndex < rop.index || prevRop.index > rop.lastIndex;
bool 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[prevRop.instructionIndex] = null; // kill first delete
rop.index = Math.Min(prevRop.index, rop.index);
rop.lastIndex = Math.Max(prevRop.lastIndex, rop.lastIndex);
Console.WriteLine("new rop " + rop);
}
else if ( !disjoint && !same )
{
throw new ArgumentException( "replace op boundaries of " + rop +
" overlap with previous " + prevRop );
}
}
}
// WALK INSERTS
for ( int i = 0; i < rewrites.Count; i++ )
{
RewriteOperation op = (RewriteOperation)rewrites[i];
if ( op == null )
continue;
if ( !( op is InsertBeforeOp ) )
continue;
InsertBeforeOp iop = (InsertBeforeOp)rewrites[i];
// combine current insert with prior if any at same index
var prevInserts = GetKindOfOps( rewrites, typeof( InsertBeforeOp ), i );
for ( int j = 0; j < prevInserts.Count; j++ )
{
InsertBeforeOp prevIop = (InsertBeforeOp)prevInserts[j];
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[prevIop.instructionIndex] = null;
}
}
// look for replaces where iop.index is in range; error
var prevReplaces = GetKindOfOps( rewrites, typeof( ReplaceOp ), i );
for ( int j = 0; j < prevReplaces.Count; j++ )
{
ReplaceOp rop = (ReplaceOp)prevReplaces[j];
if ( iop.index == rop.index )
{
rop.text = CatOpText( iop.text, rop.text );
rewrites[i] = null; // delete current insert
continue;
}
if ( iop.index >= rop.index && iop.index <= rop.lastIndex )
{
throw new ArgumentException( "insert op " + iop +
" within boundaries of previous " + rop );
}
}
}
// System.out.println("rewrites after="+rewrites);
IDictionary<int, RewriteOperation> m = new Dictionary<int, RewriteOperation>();
for ( int i = 0; i < rewrites.Count; i++ )
{
RewriteOperation op = (RewriteOperation)rewrites[i];
if ( op == null )
continue; // ignore deleted ops
RewriteOperation existing;
if ( m.TryGetValue( op.index, out existing ) && existing != null )
{
throw new Exception( "should only be one op per index" );
}
m[op.index] = op;
}
//System.out.println("index to op: "+m);
return m;
}
protected virtual string CatOpText( object a, object b )
{
return string.Concat( a, b );
}
protected virtual IList<RewriteOperation> GetKindOfOps( IList<RewriteOperation> rewrites, Type kind )
{
return GetKindOfOps( rewrites, kind, rewrites.Count );
}
/** <summary>Get all operations before an index of a particular kind</summary> */
protected virtual IList<RewriteOperation> GetKindOfOps( IList<RewriteOperation> rewrites, Type kind, int before )
{
IList<RewriteOperation> ops = new List<RewriteOperation>();
for ( int i = 0; i < before && i < rewrites.Count; i++ )
{
RewriteOperation op = rewrites[i];
if ( op == null )
continue; // ignore deleted
if ( op.GetType() == kind )
ops.Add( op );
}
return ops;
}
public virtual string ToDebugString()
{
return ToDebugString( MIN_TOKEN_INDEX, Count - 1 );
}
public virtual string ToDebugString( int start, int end )
{
StringBuilder buf = new StringBuilder();
for ( int i = start; i >= MIN_TOKEN_INDEX && i <= end && i < _tokens.Count; i++ )
{
buf.Append( Get( i ) );
}
return buf.ToString();
}
}
}