calabash-android 0.5.2 → 0.5.3

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

@@ -1,250 +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;
-
-/** A DFA implemented as a set of transition tables.
- *
- *  Any state that has a semantic predicate edge is special; those states
- *  are generated with if-then-else structures in a specialStateTransition()
- *  which is generated by cyclicDFA template.
- *
- *  There are at most 32767 states (16-bit signed short).
- *  Could get away with byte sometimes but would have to generate different
- *  types and the simulation code too.  For a point of reference, the Java
- *  lexer's Tokens rule DFA has 326 states roughly.
- */
-public class DFA {
-	protected short[] eot;
-	protected short[] eof;
-	protected char[] min;
-    protected char[] max;
-    protected short[] accept;
-    protected short[] special;
-    protected short[][] transition;
-
-	protected int decisionNumber;
-
-	/** Which recognizer encloses this DFA?  Needed to check backtracking */
-	protected BaseRecognizer recognizer;
-
-	public static final boolean debug = false;
-	private static final String TAG = "ANTLR:DFA";
-
-	/** From the input stream, predict what alternative will succeed
-	 *  using this DFA (representing the covering regular approximation
-	 *  to the underlying CFL).  Return an alternative number 1..n.  Throw
-	 *  an exception upon error.
-	 */
-	public int predict(IntStream input)
-		throws RecognitionException
-	{
-		if ( debug ) {
-			//System.err.println("Enter DFA.predict for decision "+decisionNumber);
-			android.util.Log.e(TAG, "Enter DFA.predict for decision "+decisionNumber);
-		}
-		int mark = input.mark(); // remember where decision started in input
-		int s = 0; // we always start at s0
-		try {
-			while ( true ) {
-				if ( debug ) { //System.err.println("DFA "+decisionNumber+" state "+s+" LA(1)="+(char)input.LA(1)+"("+input.LA(1)+
-												//"), index="+input.index());
-						android.util.Log.e(TAG, "DFA "+decisionNumber+" state "+s+" LA(1)="+(char)input.LA(1)+"("+input.LA(1)+
-															   "), index="+input.index());
-				}
-				int specialState = special[s];
-				if ( specialState>=0 ) {
-					if ( debug ) {
-						//System.err.println("DFA "+decisionNumber+
-							//" state "+s+" is special state "+specialState);
-						android.util.Log.e(TAG, "DFA "+decisionNumber+" state "+s+" is special state "+specialState);
-					}
-					s = specialStateTransition(specialState,input);
-					if ( debug ) {
-						//System.err.println("DFA "+decisionNumber+
-							//" returns from special state "+specialState+" to "+s);
-						android.util.Log.e(TAG, "DFA "+decisionNumber+" returns from special state "+specialState+" to "+s);
-					}
-					if ( s==-1 ) {
-						noViableAlt(s,input);
-						return 0;
-					}
-					input.consume();
-					continue;
-				}
-				if ( accept[s] >= 1 ) {
-					if ( debug ) { //System.err.println("accept; predict "+accept[s]+" from state "+s);
-							android.util.Log.e(TAG, "accept; predict "+accept[s]+" from state "+s);
-					}
-					return accept[s];
-				}
-				// look for a normal char transition
-				char c = (char)input.LA(1); // -1 == \uFFFF, all tokens fit in 65000 space
-				if (c>=min[s] && c<=max[s]) {
-					int snext = transition[s][c-min[s]]; // move to next state
-					if ( snext < 0 ) {
-						// was in range but not a normal transition
-						// must check EOT, which is like the else clause.
-						// eot[s]>=0 indicates that an EOT edge goes to another
-						// state.
-						if ( eot[s]>=0 ) {  // EOT Transition to accept state?
-							if ( debug ) { //System.err.println("EOT transition");
-								android.util.Log.e(TAG, "EOT transition");
-							}
-							s = eot[s];
-							input.consume();
-							// TODO: I had this as return accept[eot[s]]
-							// which assumed here that the EOT edge always
-							// went to an accept...faster to do this, but
-							// what about predicated edges coming from EOT
-							// target?
-							continue;
-						}
-						noViableAlt(s,input);
-						return 0;
-					}
-					s = snext;
-					input.consume();
-					continue;
-				}
-				if ( eot[s]>=0 ) {  // EOT Transition?
-					if ( debug ) { //System.err.println("EOT transition");
-							android.util.Log.e(TAG, "EOT transition");
-					}
-					s = eot[s];
-					input.consume();
-					continue;
-				}
-				if ( c==(char)Token.EOF && eof[s]>=0 ) {  // EOF Transition to accept state?
-					if ( debug ) { //System.err.println("accept via EOF; predict "+accept[eof[s]]+" from "+eof[s]);
-							android.util.Log.e(TAG, "accept via EOF; predict "+accept[eof[s]]+" from "+eof[s]);
-					}
-					return accept[eof[s]];
-				}
-				// not in range and not EOF/EOT, must be invalid symbol
-				if ( debug ) {
-					//System.err.println("min["+s+"]="+min[s]);
-					android.util.Log.e(TAG, "min["+s+"]="+min[s]);
-					//System.err.println("max["+s+"]="+max[s]);
-					android.util.Log.e(TAG, "max["+s+"]="+max[s]);
-					//System.err.println("eot["+s+"]="+eot[s]);
-					android.util.Log.e(TAG, "eot["+s+"]="+eot[s]);
-					//System.err.println("eof["+s+"]="+eof[s]);
-					android.util.Log.e(TAG, "eof["+s+"]="+eof[s]);
-					for (int p=0; p<transition[s].length; p++) {
-						//System.err.print(transition[s][p]+" ");
-						android.util.Log.e(TAG, transition[s][p]+" ");
-					}
-					//System.err.println();
-					android.util.Log.e(TAG, "");
-				}
-				noViableAlt(s,input);
-				return 0;
-			}
-		}
-		finally {
-			input.rewind(mark);
-		}
-	}
-
-	protected void noViableAlt(int s, IntStream input) throws NoViableAltException {
-		if (recognizer.state.backtracking>0) {
-			recognizer.state.failed=true;
-			return;
-		}
-		NoViableAltException nvae =
-			new NoViableAltException(getDescription(),
-									 decisionNumber,
-									 s,
-									 input);
-		error(nvae);
-		throw nvae;
-	}
-
-	/** A hook for debugging interface */
-	protected void error(NoViableAltException nvae) { ; }
-
-	public int specialStateTransition(int s, IntStream input)
-		throws NoViableAltException
-	{
-		return -1;
-	}
-
-	public String getDescription() {
-		return "n/a";
-	}
-
-	/** Given a String that has a run-length-encoding of some unsigned shorts
-	 *  like "\1\2\3\9", convert to short[] {2,9,9,9}.  We do this to avoid
-	 *  static short[] which generates so much init code that the class won't
-	 *  compile. :(
-	 */
-	public static short[] unpackEncodedString(String encodedString) {
-		// walk first to find how big it is.
-		int size = 0;
-		for (int i=0; i<encodedString.length(); i+=2) {
-			size += encodedString.charAt(i);
-		}
-		short[] data = new short[size];
-		int di = 0;
-		for (int i=0; i<encodedString.length(); i+=2) {
-			char n = encodedString.charAt(i);
-			char v = encodedString.charAt(i+1);
-			// add v n times to data
-			for (int j=1; j<=n; j++) {
-				data[di++] = (short)v;
-			}
-		}
-		return data;
-	}
-
-	/** Hideous duplication of code, but I need different typed arrays out :( */
-	public static char[] unpackEncodedStringToUnsignedChars(String encodedString) {
-		// walk first to find how big it is.
-		int size = 0;
-		for (int i=0; i<encodedString.length(); i+=2) {
-			size += encodedString.charAt(i);
-		}
-		char[] data = new char[size];
-		int di = 0;
-		for (int i=0; i<encodedString.length(); i+=2) {
-			char n = encodedString.charAt(i);
-			char v = encodedString.charAt(i+1);
-			// add v n times to data
-			for (int j=1; j<=n; j++) {
-				data[di++] = v;
-			}
-		}
-		return data;
-	}
-
-	/*
-	public int specialTransition(int state, int symbol) {
-		return 0;
-	}
-	*/
-}

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

@@ -1,41 +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;
-
-/**  The recognizer did not match anything for a (..)+ loop. */
-public class EarlyExitException extends RecognitionException {
-	public int decisionNumber;
-
-	/** Used for remote debugger deserialization */
-	public EarlyExitException() {;}
-	
-	public EarlyExitException(int decisionNumber, IntStream input) {
-		super(input);
-		this.decisionNumber = decisionNumber;
-	}
-}

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

@@ -1,54 +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;
-
-/** A semantic predicate failed during validation.  Validation of predicates
- *  occurs when normally parsing the alternative just like matching a token.
- *  Disambiguating predicate evaluation occurs when we hoist a predicate into
- *  a prediction decision.
- */
-public class FailedPredicateException extends RecognitionException {
-	public String ruleName;
-	public String predicateText;
-
-	/** Used for remote debugger deserialization */
-	public FailedPredicateException() {;}
-
-	public FailedPredicateException(IntStream input,
-									String ruleName,
-									String predicateText)
-	{
-		super(input);
-		this.ruleName = ruleName;
-		this.predicateText = predicateText;
-	}
-
-	public String toString() {
-		return "FailedPredicateException("+ruleName+",{"+predicateText+"}?)";
-	}
-}

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

@@ -1,122 +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;
-
-/** A simple stream of integers used when all I care about is the char
- *  or token type sequence (such as interpretation).
- */
-public interface IntStream {
-	void consume();
-
-	/** Get int at current input pointer + i ahead where i=1 is next int.
-	 *  Negative indexes are allowed.  LA(-1) is previous token (token
-	 *  just matched).  LA(-i) where i is before first token should
-	 *  yield -1, invalid char / EOF.
-	 */
-	int LA(int i);
-
-	/** Tell the stream to start buffering if it hasn't already.  Return
-     *  current input position, index(), or some other marker so that
-	 *  when passed to rewind() you get back to the same spot.
-	 *  rewind(mark()) should not affect the input cursor.  The Lexer
-	 *  track line/col info as well as input index so its markers are
-	 *  not pure input indexes.  Same for tree node streams.
-     */
-	int mark();
-
-	/** Return the current input symbol index 0..n where n indicates the
-     *  last symbol has been read.  The index is the symbol about to be
-	 *  read not the most recently read symbol.
-     */
-	int index();
-
-	/** Reset the stream so that next call to index would return marker.
-	 *  The marker will usually be index() but it doesn't have to be.  It's
-	 *  just a marker to indicate what state the stream was in.  This is
-	 *  essentially calling release() and seek().  If there are markers
-	 *  created after this marker argument, this routine must unroll them
-	 *  like a stack.  Assume the state the stream was in when this marker
-	 *  was created.
-	 */
-	void rewind(int marker);
-
-	/** Rewind to the input position of the last marker.
-	 *  Used currently only after a cyclic DFA and just
-	 *  before starting a sem/syn predicate to get the
-	 *  input position back to the start of the decision.
-	 *  Do not "pop" the marker off the state.  mark(i)
-	 *  and rewind(i) should balance still. It is
-	 *  like invoking rewind(last marker) but it should not "pop"
-	 *  the marker off.  It's like seek(last marker's input position).
-	 */
-	void rewind();
-
-	/** You may want to commit to a backtrack but don't want to force the
-	 *  stream to keep bookkeeping objects around for a marker that is
-	 *  no longer necessary.  This will have the same behavior as
-	 *  rewind() except it releases resources without the backward seek.
-	 *  This must throw away resources for all markers back to the marker
-	 *  argument.  So if you're nested 5 levels of mark(), and then release(2)
-	 *  you have to release resources for depths 2..5.
-	 */
-	void release(int marker);
-
-	/** Set the input cursor to the position indicated by index.  This is
-	 *  normally used to seek ahead in the input stream.  No buffering is
-	 *  required to do this unless you know your stream will use seek to
-	 *  move backwards such as when backtracking.
-	 *
-	 *  This is different from rewind in its multi-directional
-	 *  requirement and in that its argument is strictly an input cursor (index).
-	 *
-	 *  For char streams, seeking forward must update the stream state such
-	 *  as line number.  For seeking backwards, you will be presumably
-	 *  backtracking using the mark/rewind mechanism that restores state and
-	 *  so this method does not need to update state when seeking backwards.
-	 *
-	 *  Currently, this method is only used for efficient backtracking using
-	 *  memoization, but in the future it may be used for incremental parsing.
-	 *
-	 *  The index is 0..n-1.  A seek to position i means that LA(1) will
-	 *  return the ith symbol.  So, seeking to 0 means LA(1) will return the
-	 *  first element in the stream. 
-	 */
-	void seek(int index);
-
-	/** Only makes sense for streams that buffer everything up probably, but
-	 *  might be useful to display the entire stream or for testing.  This
-	 *  value includes a single EOF.
-	 */
-	int size();
-
-	/** Where are you getting symbols from?  Normally, implementations will
-	 *  pass the buck all the way to the lexer who can ask its input stream
-	 *  for the file name or whatever.
-	 */
-	public String getSourceName();
-}