testautoa 0.4.0.pre16

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

@@ -0,0 +1,250 @@
+/*
+ [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

@@ -0,0 +1,41 @@
+/*
+ [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

@@ -0,0 +1,54 @@
+/*
+ [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

@@ -0,0 +1,122 @@
+/*
+ [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();
+}