/antlr-3.4/runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime.Tree/RewriteRuleElementStream.cs
C# | 230 lines | 102 code | 18 blank | 110 comment | 25 complexity | c53e0cda086755c8090c911f4f170fed MD5 | raw file
- /*
- * [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;
- }
- }
- }
- }