/*
* [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.Tree
{
using System.Collections.Generic;
using IList = System.Collections.IList;
/** <summary>
* A generic list of elements tracked in an alternative to be used in
* a -> rewrite rule. We need to subclass to fill in the next() method,
* which returns either an AST node wrapped around a token payload or
* an existing subtree.
* </summary>
*
* <remarks>
* Once you start next()ing, do not try to add more elements. It will
* break the cursor tracking I believe.
*
* TODO: add mechanism to detect/puke on modification after reading from stream
* </remarks>
*
* <see cref="RewriteRuleSubtreeStream"/>
* <see cref="RewriteRuleTokenStream"/>
*/
[System.Serializable]
public abstract class RewriteRuleElementStream
{
/** <summary>
* Cursor 0..n-1. If singleElement!=null, cursor is 0 until you next(),
* which bumps it to 1 meaning no more elements.
* </summary>
*/
protected int cursor = 0;
/** <summary>Track single elements w/o creating a list. Upon 2nd add, alloc list */
protected object singleElement;
/** <summary>The list of tokens or subtrees we are tracking */
protected IList elements;
/** <summary>Once a node / subtree has been used in a stream, it must be dup'd
* from then on. Streams are reset after subrules so that the streams
* can be reused in future subrules. So, reset must set a dirty bit.
* If dirty, then next() always returns a dup.
*
* I wanted to use "naughty bit" here, but couldn't think of a way
* to use "naughty".
*/
protected bool dirty = false;
/** <summary>The element or stream description; usually has name of the token or
* rule reference that this list tracks. Can include rulename too, but
* the exception would track that info.
*/
protected string elementDescription;
protected ITreeAdaptor adaptor;
public RewriteRuleElementStream( ITreeAdaptor adaptor, string elementDescription )
{
this.elementDescription = elementDescription;
this.adaptor = adaptor;
}
/** <summary>Create a stream with one element</summary> */
public RewriteRuleElementStream( ITreeAdaptor adaptor, string elementDescription, object oneElement )
: this( adaptor, elementDescription )
{
Add( oneElement );
}
/** <summary>Create a stream, but feed off an existing list</summary> */
public RewriteRuleElementStream( ITreeAdaptor adaptor, string elementDescription, IList elements )
: this( adaptor, elementDescription )
{
this.singleElement = null;
this.elements = elements;
}
/** <summary>
* Reset the condition of this stream so that it appears we have
* not consumed any of its elements. Elements themselves are untouched.
* Once we reset the stream, any future use will need duplicates. Set
* the dirty bit.
* </summary>
*/
public virtual void Reset()
{
cursor = 0;
dirty = true;
}
public virtual void Add( object el )
{
//System.out.println("add '"+elementDescription+"' is "+el);
if ( el == null )
{
return;
}
if ( elements != null )
{ // if in list, just add
elements.Add( el );
return;
}
if ( singleElement == null )
{ // no elements yet, track w/o list
singleElement = el;
return;
}
// adding 2nd element, move to list
elements = new List<object>( 5 );
elements.Add( singleElement );
singleElement = null;
elements.Add( el );
}
/** <summary>
* Return the next element in the stream. If out of elements, throw
* an exception unless size()==1. If size is 1, then return elements[0].
* Return a duplicate node/subtree if stream is out of elements and
* size==1. If we've already used the element, dup (dirty bit set).
* </summary>
*/
public virtual object NextTree()
{
int n = Count;
if ( dirty || ( cursor >= n && n == 1 ) )
{
// if out of elements and size is 1, dup
object el = NextCore();
return Dup( el );
}
// test size above then fetch
object el2 = NextCore();
return el2;
}
/** <summary>
* Do the work of getting the next element, making sure that it's
* a tree node or subtree. Deal with the optimization of single-
* element list versus list of size > 1. Throw an exception
* if the stream is empty or we're out of elements and size>1.
* protected so you can override in a subclass if necessary.
* </summary>
*/
protected virtual object NextCore()
{
int n = Count;
if ( n == 0 )
{
throw new RewriteEmptyStreamException( elementDescription );
}
if ( cursor >= n )
{ // out of elements?
if ( n == 1 )
{ // if size is 1, it's ok; return and we'll dup
return ToTree( singleElement );
}
// out of elements and size was not 1, so we can't dup
throw new RewriteCardinalityException( elementDescription );
}
// we have elements
if ( singleElement != null )
{
cursor++; // move cursor even for single element list
return ToTree( singleElement );
}
// must have more than one in list, pull from elements
object o = ToTree( elements[cursor] );
cursor++;
return o;
}
/** <summary>
* When constructing trees, sometimes we need to dup a token or AST
* subtree. Dup'ing a token means just creating another AST node
* around it. For trees, you must call the adaptor.dupTree() unless
* the element is for a tree root; then it must be a node dup.
* </summary>
*/
protected abstract object Dup( object el );
/** <summary>
* Ensure stream emits trees; tokens must be converted to AST nodes.
* AST nodes can be passed through unmolested.
* </summary>
*/
protected virtual object ToTree( object el )
{
return el;
}
public virtual bool HasNext
{
get
{
return ( singleElement != null && cursor < 1 ) ||
( elements != null && cursor < elements.Count );
}
}
public virtual int Count
{
get
{
int n = 0;
if ( singleElement != null )
{
n = 1;
}
if ( elements != null )
{
return elements.Count;
}
return n;
}
}
public virtual string Description
{
get
{
return elementDescription;
}
}
}
}