calabash-android 0.5.2 → 0.5.3

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeFilter.java

@@ -1,135 +0,0 @@
-/*
- [The "BSD license"]
- Copyright (c) 2005-2009 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.runtime.tree;
-
-import org.antlr.runtime.RecognizerSharedState;
-import org.antlr.runtime.RecognitionException;
-import org.antlr.runtime.TokenStream;
-
-/**
- Cut-n-paste from material I'm not using in the book anymore (edit later
- to make sense):
-
- Now, how are we going to test these tree patterns against every
-subtree in our original tree?  In what order should we visit nodes?
-For this application, it turns out we need a simple ``apply once''
-rule application strategy and a ``down then up'' tree traversal
-strategy.  Let's look at rule application first.
-
-As we visit each node, we need to see if any of our patterns match. If
-a pattern matches, we execute the associated tree rewrite and move on
-to the next node. In other words, we only look for a single rule
-application opportunity (we'll see below that we sometimes need to
-repeatedly apply rules). The following method applies a rule in a @cl
-TreeParser (derived from a tree grammar) to a tree:
-
-here is where weReferenced code/walking/patterns/TreePatternMatcher.java
-
-It uses reflection to lookup the appropriate rule within the generated
-tree parser class (@cl Simplify in this case). Most of the time, the
-rule will not match the tree.  To avoid issuing syntax errors and
-attempting error recovery, it bumps up the backtracking level.  Upon
-failure, the invoked rule immediately returns. If you don't plan on
-using this technique in your own ANTLR-based application, don't sweat
-the details. This method boils down to ``call a rule to match a tree,
-executing any embedded actions and rewrite rules.''
-
-At this point, we know how to define tree grammar rules and how to
-apply them to a particular subtree. The final piece of the tree
-pattern matcher is the actual tree traversal. We have to get the
-correct node visitation order.  In particular, we need to perform the
-scalar-vector multiply transformation on the way down (preorder) and
-we need to reduce multiply-by-zero subtrees on the way up (postorder).
-
-To implement a top-down visitor, we do a depth first walk of the tree,
-executing an action in the preorder position. To get a bottom-up
-visitor, we execute an action in the postorder position.  ANTLR
-provides a standard @cl TreeVisitor class with a depth first search @v
-visit method. That method executes either a @m pre or @m post method
-or both. In our case, we need to call @m applyOnce in both. On the way
-down, we'll look for @r vmult patterns. On the way up,
-we'll look for @r mult0 patterns.
- */
-public class TreeFilter extends TreeParser {
-    public interface fptr {
-        public void rule() throws RecognitionException;
-    }
-
-    protected TokenStream originalTokenStream;
-    protected TreeAdaptor originalAdaptor;
-
-    public TreeFilter(TreeNodeStream input) {
-        this(input, new RecognizerSharedState());
-    }
-    public TreeFilter(TreeNodeStream input, RecognizerSharedState state) {
-        super(input, state);
-        originalAdaptor = input.getTreeAdaptor();
-        originalTokenStream = input.getTokenStream();
-    }
-
-    public void applyOnce(Object t, fptr whichRule) {
-        if ( t==null ) return;
-        try {
-            // share TreeParser object but not parsing-related state
-            state = new RecognizerSharedState();
-            input = new CommonTreeNodeStream(originalAdaptor, t);
-            ((CommonTreeNodeStream)input).setTokenStream(originalTokenStream);
-            setBacktrackingLevel(1);
-            whichRule.rule();
-            setBacktrackingLevel(0);
-        }
-        catch (RecognitionException e) { ; }
-    }
-
-    public void downup(Object t) {
-        TreeVisitor v = new TreeVisitor(new CommonTreeAdaptor());
-        TreeVisitorAction actions = new TreeVisitorAction() {
-            public Object pre(Object t)  { applyOnce(t, topdown_fptr); return t; }
-            public Object post(Object t) { applyOnce(t, bottomup_fptr); return t; }
-        };
-        v.visit(t, actions);
-    }
-        
-    fptr topdown_fptr = new fptr() {
-        public void rule() throws RecognitionException {
-            topdown();
-        }
-    };
-
-    fptr bottomup_fptr = new fptr() {
-        public void rule() throws RecognitionException {
-            bottomup();
-        }
-    };
-
-    // methods the downup strategy uses to do the up and down rules.
-    // to override, just define tree grammar rule topdown and turn on
-    // filter=true.
-    public void topdown() throws RecognitionException {;}
-    public void bottomup() throws RecognitionException {;}
-}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeIterator.java

@@ -1,131 +0,0 @@
-/*
- [The "BSD license"]
- Copyright (c) 2005-2009 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.runtime.tree;
-
-import java.util.Iterator;
-
-import org.antlr.runtime.Token;
-import org.antlr.runtime.misc.FastQueue;
-
-/** Return a node stream from a doubly-linked tree whose nodes
- *  know what child index they are.  No remove() is supported.
- *
- *  Emit navigation nodes (DOWN, UP, and EOF) to let show tree structure.
- */
-public class TreeIterator implements Iterator {
-    protected TreeAdaptor adaptor;
-    protected Object root;
-    protected Object tree;
-    protected boolean firstTime = true;
-
-    // navigation nodes to return during walk and at end
-    public Object up;
-    public Object down;
-    public Object eof;
-
-    /** If we emit UP/DOWN nodes, we need to spit out multiple nodes per
-     *  next() call.
-     */
-    protected FastQueue nodes;
-
-    public TreeIterator(Object tree) {
-        this(new CommonTreeAdaptor(),tree);
-    }
-
-    public TreeIterator(TreeAdaptor adaptor, Object tree) {
-        this.adaptor = adaptor;
-        this.tree = tree;
-        this.root = tree;
-        nodes = new FastQueue();
-        down = adaptor.create(Token.DOWN, "DOWN");
-        up = adaptor.create(Token.UP, "UP");
-        eof = adaptor.create(Token.EOF, "EOF");
-    }
-
-    public void reset() {
-        firstTime = true;
-        tree = root;
-        nodes.clear();
-    }
-
-    public boolean hasNext() {
-        if ( firstTime ) return root!=null;
-        if ( nodes!=null && nodes.size()>0 ) return true;
-        if ( tree==null ) return false;
-        if ( adaptor.getChildCount(tree)>0 ) return true;
-        return adaptor.getParent(tree)!=null; // back at root?
-    }
-
-    public Object next() {
-        if ( firstTime ) { // initial condition
-            firstTime = false;
-            if ( adaptor.getChildCount(tree)==0 ) { // single node tree (special)
-                nodes.add(eof);
-                return tree;
-            }
-            return tree;
-        }
-        // if any queued up, use those first
-        if ( nodes!=null && nodes.size()>0 ) return nodes.remove();
-
-        // no nodes left?
-        if ( tree==null ) return eof;
-
-        // next node will be child 0 if any children
-        if ( adaptor.getChildCount(tree)>0 ) {
-            tree = adaptor.getChild(tree, 0);
-            nodes.add(tree); // real node is next after DOWN
-            return down;
-        }
-        // if no children, look for next sibling of tree or ancestor
-        Object parent = adaptor.getParent(tree);
-        // while we're out of siblings, keep popping back up towards root
-        while ( parent!=null &&
-                adaptor.getChildIndex(tree)+1 >= adaptor.getChildCount(parent) )
-        {
-            nodes.add(up); // we're moving back up
-            tree = parent;
-            parent = adaptor.getParent(tree);
-        }
-        // no nodes left?
-        if ( parent==null ) {
-            tree = null; // back at root? nothing left then
-            nodes.add(eof); // add to queue, might have UP nodes in there
-            return nodes.remove();
-        }
-
-        // must have found a node with an unvisited sibling
-        // move to it and return it
-        int nextSiblingIndex = adaptor.getChildIndex(tree) + 1;
-        tree = adaptor.getChild(parent, nextSiblingIndex);
-        nodes.add(tree); // add to queue, might have UP nodes in there
-        return nodes.remove();
-    }
-
-    public void remove() { throw new UnsupportedOperationException(); }
-}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeNodeStream.java

@@ -1,106 +0,0 @@
-/*
- [The "BSD license"]
- Copyright (c) 2005-2009 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.runtime.tree;
-
-import org.antlr.runtime.IntStream;
-import org.antlr.runtime.TokenStream;
-
-/** A stream of tree nodes, accessing nodes from a tree of some kind */
-public interface TreeNodeStream extends IntStream {
-	/** Get a tree node at an absolute index i; 0..n-1.
-	 *  If you don't want to buffer up nodes, then this method makes no
-	 *  sense for you.
-	 */
-	public Object get(int i);
-
-	/** Get tree node at current input pointer + i ahead where i=1 is next node.
-	 *  i<0 indicates nodes in the past.  So LT(-1) is previous node, but
-	 *  implementations are not required to provide results for k < -1.
-	 *  LT(0) is undefined.  For i>=n, return null.
-	 *  Return null for LT(0) and any index that results in an absolute address
-	 *  that is negative.
-	 *
-	 *  This is analogus to the LT() method of the TokenStream, but this
-	 *  returns a tree node instead of a token.  Makes code gen identical
-	 *  for both parser and tree grammars. :)
-	 */
-	public Object LT(int k);
-
-	/** Where is this stream pulling nodes from?  This is not the name, but
-	 *  the object that provides node objects.
-	 */
-	public Object getTreeSource();
-
-	/** If the tree associated with this stream was created from a TokenStream,
-	 *  you can specify it here.  Used to do rule $text attribute in tree
-	 *  parser.  Optional unless you use tree parser rule text attribute
-	 *  or output=template and rewrite=true options.
-	 */
-	public TokenStream getTokenStream();
-
-	/** What adaptor can tell me how to interpret/navigate nodes and
-	 *  trees.  E.g., get text of a node.
-	 */
-	public TreeAdaptor getTreeAdaptor();
-
-	/** As we flatten the tree, we use UP, DOWN nodes to represent
-	 *  the tree structure.  When debugging we need unique nodes
-	 *  so we have to instantiate new ones.  When doing normal tree
-	 *  parsing, it's slow and a waste of memory to create unique
-	 *  navigation nodes.  Default should be false;
-	 */
-	public void setUniqueNavigationNodes(boolean uniqueNavigationNodes);
-
-    /** Reset the tree node stream in such a way that it acts like
-     *  a freshly constructed stream.
-     */
-    public void reset();
-
-	/** Return the text of all nodes from start to stop, inclusive.
-	 *  If the stream does not buffer all the nodes then it can still
-	 *  walk recursively from start until stop.  You can always return
-	 *  null or "" too, but users should not access $ruleLabel.text in
-	 *  an action of course in that case.
-	 */
-	public String toString(Object start, Object stop);
-
-
-	// REWRITING TREES (used by tree parser)
-
-	/** Replace from start to stop child index of parent with t, which might
-	 *  be a list.  Number of children may be different
-	 *  after this call.  The stream is notified because it is walking the
-	 *  tree and might need to know you are monkeying with the underlying
-	 *  tree.  Also, it might be able to modify the node stream to avoid
-	 *  restreaming for future phases.
-	 *
-	 *  If parent is null, don't do anything; must be at root of overall tree.
-	 *  Can't replace whatever points to the parent externally.  Do nothing.
-	 */
-	public void replaceChildren(Object parent, int startChildIndex, int stopChildIndex, Object t);
-}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeParser.java

@@ -1,169 +0,0 @@
-/*
- [The "BSD license"]
- Copyright (c) 2005-2009 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.runtime.tree;
-
-import org.antlr.runtime.*;
-
-import java.util.regex.Pattern;
-import java.util.regex.Matcher;
-
-/** A parser for a stream of tree nodes.  "tree grammars" result in a subclass
- *  of this.  All the error reporting and recovery is shared with Parser via
- *  the BaseRecognizer superclass.
-*/
-public class TreeParser extends BaseRecognizer {
-	public static final int DOWN = Token.DOWN;
-	public static final int UP = Token.UP;
-
-    // precompiled regex used by inContext
-    static String dotdot = ".*[^.]\\.\\.[^.].*";
-    static String doubleEtc = ".*\\.\\.\\.\\s+\\.\\.\\..*";
-    static Pattern dotdotPattern = Pattern.compile(dotdot);
-    static Pattern doubleEtcPattern = Pattern.compile(doubleEtc);
-
-	protected TreeNodeStream input;
-
-	public TreeParser(TreeNodeStream input) {
-		super(); // highlight that we go to super to set state object
-		setTreeNodeStream(input);
-	}
-
-	public TreeParser(TreeNodeStream input, RecognizerSharedState state) {
-		super(state); // share the state object with another parser
-		setTreeNodeStream(input);
-    }
-
-	public void reset() {
-		super.reset(); // reset all recognizer state variables
-		if ( input!=null ) {
-			input.seek(0); // rewind the input
-		}
-	}
-
-	/** Set the input stream */
-	public void setTreeNodeStream(TreeNodeStream input) {
-		this.input = input;
-	}
-
-	public TreeNodeStream getTreeNodeStream() {
-		return input;
-	}
-
-	public String getSourceName() {
-		return input.getSourceName();
-	}
-
-	protected Object getCurrentInputSymbol(IntStream input) {
-		return ((TreeNodeStream)input).LT(1);
-	}
-
-	protected Object getMissingSymbol(IntStream input,
-									  RecognitionException e,
-									  int expectedTokenType,
-									  BitSet follow)
-	{
-		String tokenText =
-			"<missing "+getTokenNames()[expectedTokenType]+">";
-        TreeAdaptor adaptor = ((TreeNodeStream)e.input).getTreeAdaptor();
-        return adaptor.create(new CommonToken(expectedTokenType, tokenText));
-	}
-
-    /** Match '.' in tree parser has special meaning.  Skip node or
-	 *  entire tree if node has children.  If children, scan until
-	 *  corresponding UP node.
-	 */
-	public void matchAny(IntStream ignore) { // ignore stream, copy of input
-		state.errorRecovery = false;
-		state.failed = false;
-		Object look = input.LT(1);
-		if ( input.getTreeAdaptor().getChildCount(look)==0 ) {
-			input.consume(); // not subtree, consume 1 node and return
-			return;
-		}
-		// current node is a subtree, skip to corresponding UP.
-		// must count nesting level to get right UP
-		int level=0;
-		int tokenType = input.getTreeAdaptor().getType(look);
-		while ( tokenType!=Token.EOF && !(tokenType==UP && level==0) ) {
-			input.consume();
-			look = input.LT(1);
-			tokenType = input.getTreeAdaptor().getType(look);
-			if ( tokenType == DOWN ) {
-				level++;
-			}
-			else if ( tokenType == UP ) {
-				level--;
-			}
-		}
-		input.consume(); // consume UP
-	}
-
-    /** We have DOWN/UP nodes in the stream that have no line info; override.
-	 *  plus we want to alter the exception type.  Don't try to recover
-	 *  from tree parser errors inline...
-     */
-    protected Object recoverFromMismatchedToken(IntStream input,
-                                                int ttype,
-                                                BitSet follow)
-        throws RecognitionException
-    {
-        throw new MismatchedTreeNodeException(ttype, (TreeNodeStream)input);
-    }
-
-    /** Prefix error message with the grammar name because message is
-	 *  always intended for the programmer because the parser built
-	 *  the input tree not the user.
-	 */
-	public String getErrorHeader(RecognitionException e) {
-		return getGrammarFileName()+": node from "+
-			   (e.approximateLineInfo?"after ":"")+"line "+e.line+":"+e.charPositionInLine;
-	}
-
-	/** Tree parsers parse nodes they usually have a token object as
-	 *  payload. Set the exception token and do the default behavior.
-	 */
-	public String getErrorMessage(RecognitionException e, String[] tokenNames) {
-		if ( this instanceof TreeParser ) {
-			TreeAdaptor adaptor = ((TreeNodeStream)e.input).getTreeAdaptor();
-			e.token = adaptor.getToken(e.node);
-			if ( e.token==null ) { // could be an UP/DOWN node
-				e.token = new CommonToken(adaptor.getType(e.node),
-										  adaptor.getText(e.node));
-			}
-		}
-		return super.getErrorMessage(e, tokenNames);
-	}
-
-	public void traceIn(String ruleName, int ruleIndex)  {
-		super.traceIn(ruleName, ruleIndex, input.LT(1));
-	}
-
-	public void traceOut(String ruleName, int ruleIndex)  {
-		super.traceOut(ruleName, ruleIndex, input.LT(1));
-	}
-}