diff --git a/Jenkinsfile b/Jenkinsfile new file mode 100644 index 000000000..e0dcb14b0 --- /dev/null +++ b/Jenkinsfile @@ -0,0 +1,77 @@ +#!/usr/bin/env groovy + +@Library('ds-pipeline-lib') + +import java.security.MessageDigest +def id = MessageDigest.getInstance("MD5").digest(System.currentTimeMillis().toString().bytes).encodeHex().toString().substring(0,8) + +// Build Jython forked repository and push artifacts to Artifactory +// Addresses OPSC-17995: upgrades commons-compress 1.10 -> 1.27.1 to fix CVEs + +pipeline { + agent { + node { + label 'default-runner' + customWorkspace "workspace/${BUILD_NUMBER}-package-build-${id}" + } + } + + tools { + jdk('jdk-8') + } + + parameters { + string(name: 'buildbranch', defaultValue: 'ripcord-master', description: 'The branch to build.') + } + + options { + disableConcurrentBuilds() + buildDiscarder(logRotator(numToKeepStr: '30')) + timeout(time: 120, unit: 'MINUTES') + timestamps() + } + + stages { + stage('Build') { + steps { + script { + env.JYTHON_VERSION = sh( + script: "grep -m1 'property name=\"jython.version\"' build.xml | sed 's/.*value=\"\\([^\"]*\\)\".*/\\1/'", + returnStdout: true + ).trim() + echo "Building jython-standalone version: ${env.JYTHON_VERSION}" + } + withAnt(installation: 'ant-1.10.7') { + // Use pre-generated ANTLR sources (committed in gensrc/) to skip antlr_gen. + // antlr-3.1.3 has a Java 8 NPE in ArrayList.removeAll; committing the + // generated files means the ANTLR tool never needs to run in CI. + sh "ant jar-standalone -Dgensrc.dir=${WORKSPACE}/gensrc" + sh "mkdir -p artifacts" + sh "cp dist/jython-standalone-*.jar artifacts/" + } + archiveArtifacts artifacts: 'dist/jython-standalone-*.jar', onlyIfSuccessful: true, defaultExcludes: false, caseSensitive: false + } + } + stage('Upload to Artifactory') { + steps { + script { + def directoryPath = 'artifacts' + def filenames = sh(script: "ls ${directoryPath}", returnStdout: true).trim().split('\n') + + withCredentials([usernamePassword(credentialsId: 'dse-artifactory', + usernameVariable: 'ARTIFACTORY_USER', + passwordVariable: 'ARTIFACTORY_PASSWORD')]) { + for (def filename in filenames) { + sh "curl -sSf -u '${ARTIFACTORY_USER}:${ARTIFACTORY_PASSWORD}' -X PUT -T artifacts/${filename} 'https://repo.aws.dsinternal.org/artifactory/datastax-public-releases-local/com/datastax/opscenter/jython-standalone/${env.JYTHON_VERSION}/${filename}'" + } + } + } + } + } + stage('Wrapup') { + steps { + cleanWs notFailBuild: true + } + } + } +} diff --git a/Lib/_sslcerts.py b/Lib/_sslcerts.py index 1547ed007..5a00991df 100644 --- a/Lib/_sslcerts.py +++ b/Lib/_sslcerts.py @@ -10,15 +10,8 @@ from java.security.cert import CertificateException, CertificateFactory from java.security.interfaces import RSAPrivateCrtKey from java.security.interfaces import RSAPublicKey -from javax.net.ssl import X509KeyManager, X509TrustManager, KeyManagerFactory, SSLContext - -try: - # jarjar-ed version - from org.python.netty.handler.ssl.util import SimpleTrustManagerFactory - -except ImportError: - # dev version from extlibs - from io.netty.handler.ssl.util import SimpleTrustManagerFactory +from javax.net.ssl import ( + X509KeyManager, X509TrustManager, KeyManagerFactory, SSLContext, TrustManager, TrustManagerFactory) try: # dev version from extlibs OR if in classpath. @@ -70,7 +63,7 @@ def _get_ca_certs_trust_manager(ca_certs=None): for cert in cf.generateCertificates(BufferedInputStream(f)): trust_store.setCertificateEntry(str(uuid.uuid4()), cert) num_certs_installed += 1 - tmf = SimpleTrustManagerFactory.getInstance(SimpleTrustManagerFactory.getDefaultAlgorithm()) + tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) tmf.init(trust_store) log.debug("Installed %s certificates", num_certs_installed, extra={"sock": "*"}) return tmf @@ -335,7 +328,7 @@ def chooseServerAlias(self, key_type, issuers, socket): def getPrivateKey(self, alias): for key_manager in self.key_managers: - private_key = key_manager.getPrivateKey(alias) + private_key = keyManager.getPrivateKey(alias) if private_key: return private_key return None @@ -410,13 +403,14 @@ def getAcceptedIssuers(self): return certs -class CompositeX509TrustManagerFactory(SimpleTrustManagerFactory): +# To use with CERT_NONE +class NoVerifyX509TrustManager(X509TrustManager): - def __init__(self, trust_managers): - self._trust_manager = CompositeX509TrustManager(trust_managers) + def checkClientTrusted(self, chain, auth_type): + pass - def engineInit(self, arg): + def checkServerTrusted(self, chain, auth_type): pass - def engineGetTrustManagers(self): - return [self._trust_manager] + def getAcceptedIssuers(self): + return None diff --git a/Lib/ssl.py b/Lib/ssl.py index 3a1c22343..0f8dd5b25 100644 --- a/Lib/ssl.py +++ b/Lib/ssl.py @@ -6,6 +6,7 @@ from java.io import BufferedInputStream, PrintWriter, StringWriter from java.security import KeyStore, KeyStoreException from java.security.cert import CertificateParsingException +from javax.net.ssl import TrustManagerFactory from javax.naming.ldap import LdapName from java.lang import IllegalArgumentException, System import logging @@ -18,16 +19,11 @@ try: # jarjar-ed version from org.python.netty.channel import ChannelInitializer - from org.python.netty.handler.ssl import SslHandler, SslProvider, SslContextBuilder, ClientAuth - from org.python.netty.handler.ssl.util import SimpleTrustManagerFactory, InsecureTrustManagerFactory - from org.python.netty.buffer import ByteBufAllocator - + from org.python.netty.handler.ssl import SslHandler except ImportError: # dev version from extlibs from io.netty.channel import ChannelInitializer - from io.netty.handler.ssl import SslHandler, SslProvider, SslContextBuilder, ClientAuth - from io.netty.handler.ssl.util import SimpleTrustManagerFactory, InsecureTrustManagerFactory - from io.netty.buffer import ByteBufAllocator + from io.netty.handler.ssl import SslHandler from _socket import ( SSLError, raises_java_exception, @@ -49,7 +45,7 @@ error as socket_error) from _sslcerts import _get_openssl_key_manager, _extract_cert_from_data, _extract_certs_for_paths, \ - _str_hash_key_entry, _get_ecdh_parameter_spec, CompositeX509TrustManagerFactory + NoVerifyX509TrustManager, _str_hash_key_entry, _get_ecdh_parameter_spec, CompositeX509TrustManager from _sslcerts import SSLContext as _JavaSSLContext from java.text import SimpleDateFormat @@ -59,13 +55,6 @@ from javax.security.auth.x500 import X500Principal from org.ietf.jgss import Oid -try: - # requires Java 8 or higher for this support - from javax.net.ssl import SNIHostName, SNIMatcher - HAS_SNI = True -except ImportError: - HAS_SNI = False - log = logging.getLogger("_socket") ssl_log = logging.getLogger("jython_ssl") @@ -77,10 +66,6 @@ CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED = range(3) -_CERT_TO_CLIENT_AUTH = {CERT_NONE: ClientAuth.NONE, - CERT_OPTIONAL: ClientAuth.OPTIONAL, - CERT_REQUIRED: ClientAuth.REQUIRE} - # Do not support PROTOCOL_SSLv2, it is highly insecure and it is optional _, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1, PROTOCOL_TLSv1_1, PROTOCOL_TLSv1_2 = range(6) _PROTOCOL_NAMES = { @@ -104,8 +89,7 @@ CHANNEL_BINDING_TYPES = [] # https://docs.python.org/2/library/ssl.html#ssl.HAS_ALPN etc... -HAS_ALPN, HAS_NPN, HAS_ECDH = False, False, True - +HAS_ALPN, HAS_NPN, HAS_ECDH, HAS_SNI = False, False, True, False # TODO not supported on jython yet # Disable weak or insecure ciphers by default @@ -571,17 +555,12 @@ def wrap_child(child): def context(self): return self._context - @context.setter - def context(self, context): - self._context = context - def setup_engine(self, addr): if self.engine is None: # http://stackoverflow.com/questions/13390964/java-ssl-fatal-error-80-unwrapping-net-record-after-adding-the-https-en self.engine = self._context._createSSLEngine( addr, self.server_hostname, - cert_file=getattr(self, "certfile", None), key_file=getattr(self, "keyfile", None), - server_side=self.server_side) + cert_file=getattr(self, "certfile", None), key_file=getattr(self, "keyfile", None)) self.engine.setUseClientMode(not self.server_side) def connect(self, addr): @@ -1049,8 +1028,6 @@ def __init__(self, protocol, options=None): self._key_managers = None - self._server_name_callback = None - def wrap_socket(self, sock, server_side=False, do_handshake_on_connect=True, suppress_ragged_eofs=True, @@ -1061,30 +1038,24 @@ def wrap_socket(self, sock, server_side=False, server_hostname=server_hostname, _context=self) - def _createSSLEngine(self, addr, hostname=None, cert_file=None, key_file=None, server_side=False): - tmf = InsecureTrustManagerFactory.INSTANCE - if self.verify_mode != CERT_NONE: - # XXX need to refactor so we don't have to get trust managers twice - stmf = SimpleTrustManagerFactory.getInstance(SimpleTrustManagerFactory.getDefaultAlgorithm()) - stmf.init(self._trust_store) - - tmf = CompositeX509TrustManagerFactory(stmf.getTrustManagers()) + def _createSSLEngine(self, addr, hostname=None, cert_file=None, key_file=None): + trust_managers = [NoVerifyX509TrustManager()] + if self.verify_mode == CERT_REQUIRED: + tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) tmf.init(self._trust_store) + trust_managers = [CompositeX509TrustManager(tmf.getTrustManagers())] - kmf = self._key_managers - if self._key_managers is None: - kmf = _get_openssl_key_manager(cert_file=cert_file, key_file=key_file) - - context_builder = None - - if not server_side: - context_builder = SslContextBuilder.forClient() + context = _JavaSSLContext.getInstance(self._protocol_name) - if kmf: - if server_side: - context_builder = SslContextBuilder.forServer(kmf) - else: - context_builder = context_builder.keyManager(kmf) + if self._key_managers is None: + context.init( + _get_openssl_key_manager( + cert_file=cert_file, key_file=key_file).getKeyManagers(), + trust_managers, None) + else: + context.init( + self._key_managers.getKeyManagers(), + trust_managers, None) # addr could be ipv6, only extract relevant parts engine = context.createSSLEngine((hostname or addr[0]), addr[1]) @@ -1093,22 +1064,14 @@ def _createSSLEngine(self, addr, hostname=None, cert_file=None, key_file=None, s engine.setSSLParameters(params) - context_builder = context_builder.trustManager(tmf) - context_builder = context_builder.sslProvider(SslProvider.JDK) - context_builder = context_builder.clientAuth(_CERT_TO_CLIENT_AUTH[self.verify_mode]) + # apparently this can be used to enforce hostname verification + if hostname is not None and self._check_hostname: + params = engine.getSSLParameters() + params.setEndpointIdentificationAlgorithm('HTTPS') + engine.setSSLParameters(params) if self._ciphers is not None: - context_builder = context_builder.ciphers(self._ciphers) - - if self._check_hostname: - engine = context_builder.build().newEngine(ByteBufAllocator.DEFAULT, hostname, addr[1]) - if HAS_SNI: - params = engine.getSSLParameters() - params.setEndpointIdentificationAlgorithm('HTTPS') - params.setServerNames([SNIHostName(hostname)]) - engine.setSSLParameters(params) - else: - engine = context_builder.build().newEngine(ByteBufAllocator.DEFAULT, addr[0], addr[1]) + engine.setEnabledCipherSuites(self._ciphers) return engine @@ -1192,10 +1155,7 @@ def set_npn_protocols(self, protocols): raise NotImplementedError() def set_servername_callback(self, server_name_callback): - if not callable(server_name_callback) and server_name_callback is not None: - raise TypeError("{!r} is not callable".format(server_name_callback)) - self._server_name_callback = server_name_callback - + raise NotImplementedError() def load_dh_params(self, dhfile): # TODO? diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py index 0cf668546..126f794f7 100644 --- a/Lib/test/test_ssl.py +++ b/Lib/test/test_ssl.py @@ -1521,7 +1521,7 @@ def test_algorithms(self): if ssl.OPENSSL_VERSION_INFO < (0, 9, 8, 0, 15): self.skipTest("SHA256 not available on %r" % ssl.OPENSSL_VERSION) # sha256.tbs-internet.com needs SNI to use the correct certificate - if not ssl.HAS_SNI or support.is_jython: # sha256.tbs-internet.com is no longer alive + if not ssl.HAS_SNI: self.skipTest("SNI needed for this test") # https://sha2.hboeck.de/ was used until 2011-01-08 (no route to host) remote = ("sha256.tbs-internet.com", 443) diff --git a/build.xml b/build.xml index 7d619837f..b750d4fbf 100644 --- a/build.xml +++ b/build.xml @@ -84,11 +84,11 @@ oracle.jar=C:/workspace/HEAD/for_development/bisdevsrv28/jboss/server/infra/lib/ - - + + - + @@ -132,7 +132,7 @@ oracle.jar=C:/workspace/HEAD/for_development/bisdevsrv28/jboss/server/infra/lib/ - + @@ -145,9 +145,9 @@ oracle.jar=C:/workspace/HEAD/for_development/bisdevsrv28/jboss/server/infra/lib/ - - - + + + @@ -164,7 +164,7 @@ oracle.jar=C:/workspace/HEAD/for_development/bisdevsrv28/jboss/server/infra/lib/ - + @@ -183,7 +183,7 @@ oracle.jar=C:/workspace/HEAD/for_development/bisdevsrv28/jboss/server/infra/lib/ - + @@ -557,8 +557,8 @@ The readme text for the next release will be like: - - + + @@ -568,7 +568,7 @@ The readme text for the next release will be like: - + diff --git a/extlibs/antlr-complete-3.5.2.jar b/extlibs/antlr-complete-3.5.2.jar new file mode 100644 index 000000000..260de7634 Binary files /dev/null and b/extlibs/antlr-complete-3.5.2.jar differ diff --git a/extlibs/commons-compress-1.10.jar b/extlibs/commons-compress-1.10.jar deleted file mode 100644 index 75ced20e1..000000000 Binary files a/extlibs/commons-compress-1.10.jar and /dev/null differ diff --git a/extlibs/commons-compress-1.27.1.jar b/extlibs/commons-compress-1.27.1.jar new file mode 100644 index 000000000..1bea2d9ca Binary files /dev/null and b/extlibs/commons-compress-1.27.1.jar differ diff --git a/gensrc/org/python/antlr/Python.tokens b/gensrc/org/python/antlr/Python.tokens new file mode 100644 index 000000000..205f26237 --- /dev/null +++ b/gensrc/org/python/antlr/Python.tokens @@ -0,0 +1,95 @@ +PRINT=11 +VBAREQUAL=57 +MINUS=76 +TRAILBACKSLASH=6 +SLASHEQUAL=54 +BREAK=15 +IF=27 +LESSEQUAL=68 +ELIF=20 +IN=29 +DOT=10 +LPAREN=43 +IS=30 +AS=13 +AT=42 +PASS=35 +LBRACK=81 +LEADING_WS=8 +LONGINT=87 +SEMI=50 +ASSIGN=46 +CIRCUMFLEXEQUAL=58 +DOUBLESTAREQUAL=61 +COMMENT=96 +INDENT=4 +IMPORT=28 +DELETE=19 +ESC=95 +ALT_NOTEQUAL=69 +RCURLY=84 +COMMA=47 +TRIQUOTE=94 +YIELD=41 +STAREQUAL=53 +GREATER=65 +LCURLY=83 +DOUBLESLASHEQUAL=62 +RAISE=36 +CONTINUE=17 +LEFTSHIFTEQUAL=59 +STAR=48 +PERCENT=78 +STRING=90 +BACKQUOTE=85 +CLASS=16 +FROM=24 +FINALLY=23 +RIGHTSHIFTEQUAL=60 +TRY=38 +NEWLINE=7 +FOR=25 +RPAREN=44 +EXCEPT=21 +RIGHTSHIFT=63 +NAME=9 +LAMBDA=31 +NOTEQUAL=70 +EXEC=22 +NOT=32 +RBRACK=82 +AND=12 +PERCENTEQUAL=55 +LESS=64 +LEFTSHIFT=74 +PLUS=75 +DOUBLESTAR=49 +FLOAT=88 +TRIAPOS=93 +Exponent=92 +DIGITS=91 +INT=86 +DOUBLESLASH=79 +RETURN=37 +GLOBAL=26 +CONTINUED_LINE=97 +WS=98 +CIRCUMFLEX=72 +COMPLEX=89 +OR=33 +DEF=18 +ASSERT=14 +AMPEREQUAL=56 +EQUAL=66 +SLASH=77 +AMPER=73 +COLON=45 +ORELSE=34 +WITH=40 +VBAR=71 +PLUSEQUAL=51 +MINUSEQUAL=52 +GREATEREQUAL=67 +WHILE=39 +TILDE=80 +DEDENT=5 diff --git a/gensrc/org/python/antlr/PythonLexer.java b/gensrc/org/python/antlr/PythonLexer.java new file mode 100644 index 000000000..cdd2f015b --- /dev/null +++ b/gensrc/org/python/antlr/PythonLexer.java @@ -0,0 +1,5275 @@ +// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 /Users/orion.moore/apps/code/jython/grammar/Python.g 2026-08-02 11:57:27 + +package org.python.antlr; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +public class PythonLexer extends Lexer { + public static final int PRINT=11; + public static final int VBAREQUAL=57; + public static final int MINUS=76; + public static final int TRAILBACKSLASH=6; + public static final int SLASHEQUAL=54; + public static final int BREAK=15; + public static final int IF=27; + public static final int LESSEQUAL=68; + public static final int ELIF=20; + public static final int IN=29; + public static final int DOT=10; + public static final int LPAREN=43; + public static final int IS=30; + public static final int AS=13; + public static final int AT=42; + public static final int PASS=35; + public static final int LBRACK=81; + public static final int LEADING_WS=8; + public static final int LONGINT=87; + public static final int SEMI=50; + public static final int ASSIGN=46; + public static final int CIRCUMFLEXEQUAL=58; + public static final int DOUBLESTAREQUAL=61; + public static final int COMMENT=96; + public static final int INDENT=4; + public static final int IMPORT=28; + public static final int DELETE=19; + public static final int ESC=95; + public static final int ALT_NOTEQUAL=69; + public static final int RCURLY=84; + public static final int COMMA=47; + public static final int TRIQUOTE=94; + public static final int YIELD=41; + public static final int STAREQUAL=53; + public static final int GREATER=65; + public static final int LCURLY=83; + public static final int DOUBLESLASHEQUAL=62; + public static final int RAISE=36; + public static final int CONTINUE=17; + public static final int LEFTSHIFTEQUAL=59; + public static final int STAR=48; + public static final int PERCENT=78; + public static final int STRING=90; + public static final int BACKQUOTE=85; + public static final int CLASS=16; + public static final int FROM=24; + public static final int FINALLY=23; + public static final int RIGHTSHIFTEQUAL=60; + public static final int TRY=38; + public static final int NEWLINE=7; + public static final int FOR=25; + public static final int RPAREN=44; + public static final int EXCEPT=21; + public static final int RIGHTSHIFT=63; + public static final int NAME=9; + public static final int LAMBDA=31; + public static final int NOTEQUAL=70; + public static final int EXEC=22; + public static final int NOT=32; + public static final int RBRACK=82; + public static final int AND=12; + public static final int PERCENTEQUAL=55; + public static final int LESS=64; + public static final int LEFTSHIFT=74; + public static final int PLUS=75; + public static final int DOUBLESTAR=49; + public static final int FLOAT=88; + public static final int TRIAPOS=93; + public static final int Exponent=92; + public static final int DIGITS=91; + public static final int INT=86; + public static final int DOUBLESLASH=79; + public static final int RETURN=37; + public static final int GLOBAL=26; + public static final int CONTINUED_LINE=97; + public static final int WS=98; + public static final int EOF=-1; + public static final int CIRCUMFLEX=72; + public static final int COMPLEX=89; + public static final int OR=33; + public static final int DEF=18; + public static final int ASSERT=14; + public static final int AMPEREQUAL=56; + public static final int EQUAL=66; + public static final int SLASH=77; + public static final int AMPER=73; + public static final int COLON=45; + public static final int ORELSE=34; + public static final int WITH=40; + public static final int VBAR=71; + public static final int PLUSEQUAL=51; + public static final int MINUSEQUAL=52; + public static final int GREATEREQUAL=67; + public static final int WHILE=39; + public static final int TILDE=80; + public static final int DEDENT=5; + + /** Handles context-sensitive lexing of implicit line joining such as + * the case where newline is ignored in cases like this: + * a = [3, + * 4] + */ + int implicitLineJoiningLevel = 0; + int startPos=-1; + + //For use in partial parsing. + public boolean eofWhileNested = false; + public boolean partial = false; + public boolean single = false; + + //If you want to use another error recovery mechanism change this + //and the same one in the parser. + private ErrorHandler errorHandler; + + public void setErrorHandler(ErrorHandler eh) { + this.errorHandler = eh; + } + + /** + * Taken directly from antlr's Lexer.java -- needs to be re-integrated every time + * we upgrade from Antlr (need to consider a Lexer subclass, though the issue would + * remain). + */ + public Token nextToken() { + startPos = getCharPositionInLine(); + while (true) { + state.token = null; + state.channel = Token.DEFAULT_CHANNEL; + state.tokenStartCharIndex = input.index(); + state.tokenStartCharPositionInLine = input.getCharPositionInLine(); + state.tokenStartLine = input.getLine(); + state.text = null; + if ( input.LA(1)==CharStream.EOF ) { + if (implicitLineJoiningLevel > 0) { + eofWhileNested = true; + } + return Token.EOF_TOKEN; + } + try { + mTokens(); + if ( state.token==null ) { + emit(); + } + else if ( state.token==Token.SKIP_TOKEN ) { + continue; + } + return state.token; + } catch (NoViableAltException nva) { + reportError(nva); + errorHandler.recover(this, nva); // throw out current char and try again + } catch (FailedPredicateException fp) { + //XXX: added this for failed STRINGPART -- the FailedPredicateException + // hides a NoViableAltException. This should be the only + // FailedPredicateException that gets thrown by the lexer. + reportError(fp); + errorHandler.recover(this, fp); // throw out current char and try again + } catch (RecognitionException re) { + reportError(re); + // match() routine has already called recover() + } + } + } + @Override + public void displayRecognitionError(String[] tokenNames, RecognitionException e) { + //Do nothing. We will handle error display elsewhere. + } + + + + // delegates + // delegators + + public PythonLexer() {;} + public PythonLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public PythonLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "/Users/orion.moore/apps/code/jython/grammar/Python.g"; } + + // $ANTLR start "AS" + public final void mAS() throws RecognitionException { + try { + int _type = AS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2206:11: ( 'as' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2206:13: 'as' + { + match("as"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AS" + + // $ANTLR start "ASSERT" + public final void mASSERT() throws RecognitionException { + try { + int _type = ASSERT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2207:11: ( 'assert' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2207:13: 'assert' + { + match("assert"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ASSERT" + + // $ANTLR start "BREAK" + public final void mBREAK() throws RecognitionException { + try { + int _type = BREAK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2208:11: ( 'break' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2208:13: 'break' + { + match("break"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "BREAK" + + // $ANTLR start "CLASS" + public final void mCLASS() throws RecognitionException { + try { + int _type = CLASS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2209:11: ( 'class' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2209:13: 'class' + { + match("class"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CLASS" + + // $ANTLR start "CONTINUE" + public final void mCONTINUE() throws RecognitionException { + try { + int _type = CONTINUE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2210:11: ( 'continue' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2210:13: 'continue' + { + match("continue"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CONTINUE" + + // $ANTLR start "DEF" + public final void mDEF() throws RecognitionException { + try { + int _type = DEF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2211:11: ( 'def' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2211:13: 'def' + { + match("def"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DEF" + + // $ANTLR start "DELETE" + public final void mDELETE() throws RecognitionException { + try { + int _type = DELETE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2212:11: ( 'del' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2212:13: 'del' + { + match("del"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DELETE" + + // $ANTLR start "ELIF" + public final void mELIF() throws RecognitionException { + try { + int _type = ELIF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2213:11: ( 'elif' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2213:13: 'elif' + { + match("elif"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ELIF" + + // $ANTLR start "EXCEPT" + public final void mEXCEPT() throws RecognitionException { + try { + int _type = EXCEPT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2214:11: ( 'except' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2214:13: 'except' + { + match("except"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EXCEPT" + + // $ANTLR start "EXEC" + public final void mEXEC() throws RecognitionException { + try { + int _type = EXEC; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2215:11: ( 'exec' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2215:13: 'exec' + { + match("exec"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EXEC" + + // $ANTLR start "FINALLY" + public final void mFINALLY() throws RecognitionException { + try { + int _type = FINALLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2216:11: ( 'finally' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2216:13: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FINALLY" + + // $ANTLR start "FROM" + public final void mFROM() throws RecognitionException { + try { + int _type = FROM; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2217:11: ( 'from' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2217:13: 'from' + { + match("from"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FROM" + + // $ANTLR start "FOR" + public final void mFOR() throws RecognitionException { + try { + int _type = FOR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2218:11: ( 'for' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2218:13: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FOR" + + // $ANTLR start "GLOBAL" + public final void mGLOBAL() throws RecognitionException { + try { + int _type = GLOBAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2219:11: ( 'global' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2219:13: 'global' + { + match("global"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GLOBAL" + + // $ANTLR start "IF" + public final void mIF() throws RecognitionException { + try { + int _type = IF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2220:11: ( 'if' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2220:13: 'if' + { + match("if"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IF" + + // $ANTLR start "IMPORT" + public final void mIMPORT() throws RecognitionException { + try { + int _type = IMPORT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2221:11: ( 'import' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2221:13: 'import' + { + match("import"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IMPORT" + + // $ANTLR start "IN" + public final void mIN() throws RecognitionException { + try { + int _type = IN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2222:11: ( 'in' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2222:13: 'in' + { + match("in"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IN" + + // $ANTLR start "IS" + public final void mIS() throws RecognitionException { + try { + int _type = IS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2223:11: ( 'is' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2223:13: 'is' + { + match("is"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IS" + + // $ANTLR start "LAMBDA" + public final void mLAMBDA() throws RecognitionException { + try { + int _type = LAMBDA; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2224:11: ( 'lambda' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2224:13: 'lambda' + { + match("lambda"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LAMBDA" + + // $ANTLR start "ORELSE" + public final void mORELSE() throws RecognitionException { + try { + int _type = ORELSE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2225:11: ( 'else' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2225:13: 'else' + { + match("else"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ORELSE" + + // $ANTLR start "PASS" + public final void mPASS() throws RecognitionException { + try { + int _type = PASS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2226:11: ( 'pass' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2226:13: 'pass' + { + match("pass"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PASS" + + // $ANTLR start "PRINT" + public final void mPRINT() throws RecognitionException { + try { + int _type = PRINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2227:11: ( 'print' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2227:13: 'print' + { + match("print"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PRINT" + + // $ANTLR start "RAISE" + public final void mRAISE() throws RecognitionException { + try { + int _type = RAISE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2228:11: ( 'raise' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2228:13: 'raise' + { + match("raise"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RAISE" + + // $ANTLR start "RETURN" + public final void mRETURN() throws RecognitionException { + try { + int _type = RETURN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2229:11: ( 'return' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2229:13: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RETURN" + + // $ANTLR start "TRY" + public final void mTRY() throws RecognitionException { + try { + int _type = TRY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2230:11: ( 'try' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2230:13: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "TRY" + + // $ANTLR start "WHILE" + public final void mWHILE() throws RecognitionException { + try { + int _type = WHILE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2231:11: ( 'while' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2231:13: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WHILE" + + // $ANTLR start "WITH" + public final void mWITH() throws RecognitionException { + try { + int _type = WITH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2232:11: ( 'with' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2232:13: 'with' + { + match("with"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WITH" + + // $ANTLR start "YIELD" + public final void mYIELD() throws RecognitionException { + try { + int _type = YIELD; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2233:11: ( 'yield' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2233:13: 'yield' + { + match("yield"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "YIELD" + + // $ANTLR start "LPAREN" + public final void mLPAREN() throws RecognitionException { + try { + int _type = LPAREN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2235:11: ( '(' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2235:13: '(' + { + match('('); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LPAREN" + + // $ANTLR start "RPAREN" + public final void mRPAREN() throws RecognitionException { + try { + int _type = RPAREN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2237:11: ( ')' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2237:13: ')' + { + match(')'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RPAREN" + + // $ANTLR start "LBRACK" + public final void mLBRACK() throws RecognitionException { + try { + int _type = LBRACK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2239:11: ( '[' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2239:13: '[' + { + match('['); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LBRACK" + + // $ANTLR start "RBRACK" + public final void mRBRACK() throws RecognitionException { + try { + int _type = RBRACK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2241:11: ( ']' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2241:13: ']' + { + match(']'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RBRACK" + + // $ANTLR start "COLON" + public final void mCOLON() throws RecognitionException { + try { + int _type = COLON; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2243:11: ( ':' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2243:13: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COLON" + + // $ANTLR start "COMMA" + public final void mCOMMA() throws RecognitionException { + try { + int _type = COMMA; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2245:10: ( ',' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2245:12: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMMA" + + // $ANTLR start "SEMI" + public final void mSEMI() throws RecognitionException { + try { + int _type = SEMI; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2247:9: ( ';' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2247:11: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SEMI" + + // $ANTLR start "PLUS" + public final void mPLUS() throws RecognitionException { + try { + int _type = PLUS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2249:9: ( '+' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2249:11: '+' + { + match('+'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PLUS" + + // $ANTLR start "MINUS" + public final void mMINUS() throws RecognitionException { + try { + int _type = MINUS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2251:10: ( '-' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2251:12: '-' + { + match('-'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "MINUS" + + // $ANTLR start "STAR" + public final void mSTAR() throws RecognitionException { + try { + int _type = STAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2253:9: ( '*' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2253:11: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STAR" + + // $ANTLR start "SLASH" + public final void mSLASH() throws RecognitionException { + try { + int _type = SLASH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2255:10: ( '/' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2255:12: '/' + { + match('/'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SLASH" + + // $ANTLR start "VBAR" + public final void mVBAR() throws RecognitionException { + try { + int _type = VBAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2257:9: ( '|' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2257:11: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "VBAR" + + // $ANTLR start "AMPER" + public final void mAMPER() throws RecognitionException { + try { + int _type = AMPER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2259:10: ( '&' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2259:12: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AMPER" + + // $ANTLR start "LESS" + public final void mLESS() throws RecognitionException { + try { + int _type = LESS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2261:9: ( '<' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2261:11: '<' + { + match('<'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LESS" + + // $ANTLR start "GREATER" + public final void mGREATER() throws RecognitionException { + try { + int _type = GREATER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2263:12: ( '>' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2263:14: '>' + { + match('>'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GREATER" + + // $ANTLR start "ASSIGN" + public final void mASSIGN() throws RecognitionException { + try { + int _type = ASSIGN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2265:11: ( '=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2265:13: '=' + { + match('='); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ASSIGN" + + // $ANTLR start "PERCENT" + public final void mPERCENT() throws RecognitionException { + try { + int _type = PERCENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2267:12: ( '%' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2267:14: '%' + { + match('%'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PERCENT" + + // $ANTLR start "BACKQUOTE" + public final void mBACKQUOTE() throws RecognitionException { + try { + int _type = BACKQUOTE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2269:14: ( '`' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2269:16: '`' + { + match('`'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "BACKQUOTE" + + // $ANTLR start "LCURLY" + public final void mLCURLY() throws RecognitionException { + try { + int _type = LCURLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2271:11: ( '{' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2271:13: '{' + { + match('{'); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LCURLY" + + // $ANTLR start "RCURLY" + public final void mRCURLY() throws RecognitionException { + try { + int _type = RCURLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2273:11: ( '}' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2273:13: '}' + { + match('}'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RCURLY" + + // $ANTLR start "CIRCUMFLEX" + public final void mCIRCUMFLEX() throws RecognitionException { + try { + int _type = CIRCUMFLEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2275:15: ( '^' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2275:17: '^' + { + match('^'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CIRCUMFLEX" + + // $ANTLR start "TILDE" + public final void mTILDE() throws RecognitionException { + try { + int _type = TILDE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2277:10: ( '~' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2277:12: '~' + { + match('~'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "TILDE" + + // $ANTLR start "EQUAL" + public final void mEQUAL() throws RecognitionException { + try { + int _type = EQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2279:10: ( '==' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2279:12: '==' + { + match("=="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EQUAL" + + // $ANTLR start "NOTEQUAL" + public final void mNOTEQUAL() throws RecognitionException { + try { + int _type = NOTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2281:13: ( '!=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2281:15: '!=' + { + match("!="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NOTEQUAL" + + // $ANTLR start "ALT_NOTEQUAL" + public final void mALT_NOTEQUAL() throws RecognitionException { + try { + int _type = ALT_NOTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2283:13: ( '<>' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2283:15: '<>' + { + match("<>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ALT_NOTEQUAL" + + // $ANTLR start "LESSEQUAL" + public final void mLESSEQUAL() throws RecognitionException { + try { + int _type = LESSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2285:14: ( '<=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2285:16: '<=' + { + match("<="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LESSEQUAL" + + // $ANTLR start "LEFTSHIFT" + public final void mLEFTSHIFT() throws RecognitionException { + try { + int _type = LEFTSHIFT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2287:14: ( '<<' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2287:16: '<<' + { + match("<<"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LEFTSHIFT" + + // $ANTLR start "GREATEREQUAL" + public final void mGREATEREQUAL() throws RecognitionException { + try { + int _type = GREATEREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2289:17: ( '>=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2289:19: '>=' + { + match(">="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GREATEREQUAL" + + // $ANTLR start "RIGHTSHIFT" + public final void mRIGHTSHIFT() throws RecognitionException { + try { + int _type = RIGHTSHIFT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2291:15: ( '>>' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2291:17: '>>' + { + match(">>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RIGHTSHIFT" + + // $ANTLR start "PLUSEQUAL" + public final void mPLUSEQUAL() throws RecognitionException { + try { + int _type = PLUSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2293:14: ( '+=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2293:16: '+=' + { + match("+="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PLUSEQUAL" + + // $ANTLR start "MINUSEQUAL" + public final void mMINUSEQUAL() throws RecognitionException { + try { + int _type = MINUSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2295:15: ( '-=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2295:17: '-=' + { + match("-="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "MINUSEQUAL" + + // $ANTLR start "DOUBLESTAR" + public final void mDOUBLESTAR() throws RecognitionException { + try { + int _type = DOUBLESTAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2297:15: ( '**' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2297:17: '**' + { + match("**"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESTAR" + + // $ANTLR start "STAREQUAL" + public final void mSTAREQUAL() throws RecognitionException { + try { + int _type = STAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2299:14: ( '*=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2299:16: '*=' + { + match("*="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STAREQUAL" + + // $ANTLR start "DOUBLESLASH" + public final void mDOUBLESLASH() throws RecognitionException { + try { + int _type = DOUBLESLASH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2301:16: ( '//' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2301:18: '//' + { + match("//"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESLASH" + + // $ANTLR start "SLASHEQUAL" + public final void mSLASHEQUAL() throws RecognitionException { + try { + int _type = SLASHEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2303:15: ( '/=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2303:17: '/=' + { + match("/="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SLASHEQUAL" + + // $ANTLR start "VBAREQUAL" + public final void mVBAREQUAL() throws RecognitionException { + try { + int _type = VBAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2305:14: ( '|=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2305:16: '|=' + { + match("|="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "VBAREQUAL" + + // $ANTLR start "PERCENTEQUAL" + public final void mPERCENTEQUAL() throws RecognitionException { + try { + int _type = PERCENTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2307:17: ( '%=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2307:19: '%=' + { + match("%="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PERCENTEQUAL" + + // $ANTLR start "AMPEREQUAL" + public final void mAMPEREQUAL() throws RecognitionException { + try { + int _type = AMPEREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2309:15: ( '&=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2309:17: '&=' + { + match("&="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AMPEREQUAL" + + // $ANTLR start "CIRCUMFLEXEQUAL" + public final void mCIRCUMFLEXEQUAL() throws RecognitionException { + try { + int _type = CIRCUMFLEXEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2311:20: ( '^=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2311:22: '^=' + { + match("^="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CIRCUMFLEXEQUAL" + + // $ANTLR start "LEFTSHIFTEQUAL" + public final void mLEFTSHIFTEQUAL() throws RecognitionException { + try { + int _type = LEFTSHIFTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2313:19: ( '<<=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2313:21: '<<=' + { + match("<<="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LEFTSHIFTEQUAL" + + // $ANTLR start "RIGHTSHIFTEQUAL" + public final void mRIGHTSHIFTEQUAL() throws RecognitionException { + try { + int _type = RIGHTSHIFTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2315:20: ( '>>=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2315:22: '>>=' + { + match(">>="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RIGHTSHIFTEQUAL" + + // $ANTLR start "DOUBLESTAREQUAL" + public final void mDOUBLESTAREQUAL() throws RecognitionException { + try { + int _type = DOUBLESTAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2317:20: ( '**=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2317:22: '**=' + { + match("**="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESTAREQUAL" + + // $ANTLR start "DOUBLESLASHEQUAL" + public final void mDOUBLESLASHEQUAL() throws RecognitionException { + try { + int _type = DOUBLESLASHEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2319:21: ( '//=' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2319:23: '//=' + { + match("//="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESLASHEQUAL" + + // $ANTLR start "DOT" + public final void mDOT() throws RecognitionException { + try { + int _type = DOT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2321:5: ( '.' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2321:7: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOT" + + // $ANTLR start "AT" + public final void mAT() throws RecognitionException { + try { + int _type = AT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2323:4: ( '@' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2323:6: '@' + { + match('@'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AT" + + // $ANTLR start "AND" + public final void mAND() throws RecognitionException { + try { + int _type = AND; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2325:5: ( 'and' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2325:7: 'and' + { + match("and"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AND" + + // $ANTLR start "OR" + public final void mOR() throws RecognitionException { + try { + int _type = OR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2327:4: ( 'or' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2327:6: 'or' + { + match("or"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "OR" + + // $ANTLR start "NOT" + public final void mNOT() throws RecognitionException { + try { + int _type = NOT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2329:5: ( 'not' ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2329:7: 'not' + { + match("not"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NOT" + + // $ANTLR start "FLOAT" + public final void mFLOAT() throws RecognitionException { + try { + int _type = FLOAT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2332:5: ( '.' DIGITS ( Exponent )? | DIGITS '.' Exponent | DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent ) ) + int alt5=3; + alt5 = dfa5.predict(input); + switch (alt5) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2332:9: '.' DIGITS ( Exponent )? + { + match('.'); + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2332:20: ( Exponent )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='E'||LA1_0=='e') ) { + alt1=1; + } + switch (alt1) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2332:21: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2333:9: DIGITS '.' Exponent + { + mDIGITS(); + match('.'); + mExponent(); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:9: DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent ) + { + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:16: ( '.' ( DIGITS ( Exponent )? )? | Exponent ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='.') ) { + alt4=1; + } + else if ( (LA4_0=='E'||LA4_0=='e') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:17: '.' ( DIGITS ( Exponent )? )? + { + match('.'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:21: ( DIGITS ( Exponent )? )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( ((LA3_0>='0' && LA3_0<='9')) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:22: DIGITS ( Exponent )? + { + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:29: ( Exponent )? + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='E'||LA2_0=='e') ) { + alt2=1; + } + switch (alt2) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:30: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2334:45: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FLOAT" + + // $ANTLR start "LONGINT" + public final void mLONGINT() throws RecognitionException { + try { + int _type = LONGINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2338:5: ( INT ( 'l' | 'L' ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2338:9: INT ( 'l' | 'L' ) + { + mINT(); + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LONGINT" + + // $ANTLR start "Exponent" + public final void mExponent() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2343:5: ( ( 'e' | 'E' ) ( '+' | '-' )? DIGITS ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2343:10: ( 'e' | 'E' ) ( '+' | '-' )? DIGITS + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2343:22: ( '+' | '-' )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='+'||LA6_0=='-') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mDIGITS(); + + } + + } + finally { + } + } + // $ANTLR end "Exponent" + + // $ANTLR start "INT" + public final void mINT() throws RecognitionException { + try { + int _type = INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2346:5: ( '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | '0' ( 'o' | 'O' ) ( '0' .. '7' )* | '0' ( '0' .. '7' )* | '0' ( 'b' | 'B' ) ( '0' .. '1' )* | '1' .. '9' ( DIGITS )* ) + int alt12=5; + int LA12_0 = input.LA(1); + + if ( (LA12_0=='0') ) { + switch ( input.LA(2) ) { + case 'X': + case 'x': + { + alt12=1; + } + break; + case 'O': + case 'o': + { + alt12=2; + } + break; + case 'B': + case 'b': + { + alt12=4; + } + break; + default: + alt12=3;} + + } + else if ( ((LA12_0>='1' && LA12_0<='9')) ) { + alt12=5; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + switch (alt12) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2347:9: '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ + { + match('0'); + if ( input.LA(1)=='X'||input.LA(1)=='x' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2347:25: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ + int cnt7=0; + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||(LA7_0>='A' && LA7_0<='F')||(LA7_0>='a' && LA7_0<='f')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt7 >= 1 ) break loop7; + EarlyExitException eee = + new EarlyExitException(7, input); + throw eee; + } + cnt7++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2349:9: '0' ( 'o' | 'O' ) ( '0' .. '7' )* + { + match('0'); + if ( input.LA(1)=='O'||input.LA(1)=='o' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2349:25: ( '0' .. '7' )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='7')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2349:27: '0' .. '7' + { + matchRange('0','7'); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2350:9: '0' ( '0' .. '7' )* + { + match('0'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2350:14: ( '0' .. '7' )* + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( ((LA9_0>='0' && LA9_0<='7')) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2350:16: '0' .. '7' + { + matchRange('0','7'); + + } + break; + + default : + break loop9; + } + } while (true); + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2352:9: '0' ( 'b' | 'B' ) ( '0' .. '1' )* + { + match('0'); + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2352:25: ( '0' .. '1' )* + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( ((LA10_0>='0' && LA10_0<='1')) ) { + alt10=1; + } + + + switch (alt10) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2352:27: '0' .. '1' + { + matchRange('0','1'); + + } + break; + + default : + break loop10; + } + } while (true); + + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2354:9: '1' .. '9' ( DIGITS )* + { + matchRange('1','9'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2354:18: ( DIGITS )* + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( ((LA11_0>='0' && LA11_0<='9')) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2354:18: DIGITS + { + mDIGITS(); + + } + break; + + default : + break loop11; + } + } while (true); + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "INT" + + // $ANTLR start "COMPLEX" + public final void mCOMPLEX() throws RecognitionException { + try { + int _type = COMPLEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2358:5: ( ( DIGITS )+ ( 'j' | 'J' ) | FLOAT ( 'j' | 'J' ) ) + int alt14=2; + alt14 = dfa14.predict(input); + switch (alt14) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2358:9: ( DIGITS )+ ( 'j' | 'J' ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2358:9: ( DIGITS )+ + int cnt13=0; + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2358:9: DIGITS + { + mDIGITS(); + + } + break; + + default : + if ( cnt13 >= 1 ) break loop13; + EarlyExitException eee = + new EarlyExitException(13, input); + throw eee; + } + cnt13++; + } while (true); + + if ( input.LA(1)=='J'||input.LA(1)=='j' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2359:9: FLOAT ( 'j' | 'J' ) + { + mFLOAT(); + if ( input.LA(1)=='J'||input.LA(1)=='j' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMPLEX" + + // $ANTLR start "DIGITS" + public final void mDIGITS() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2363:8: ( ( '0' .. '9' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2363:10: ( '0' .. '9' )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2363:10: ( '0' .. '9' )+ + int cnt15=0; + loop15: + do { + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='0' && LA15_0<='9')) ) { + alt15=1; + } + + + switch (alt15) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2363:12: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt15 >= 1 ) break loop15; + EarlyExitException eee = + new EarlyExitException(15, input); + throw eee; + } + cnt15++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "DIGITS" + + // $ANTLR start "NAME" + public final void mNAME() throws RecognitionException { + try { + int _type = NAME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2365:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2365:10: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2366:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + + if ( ((LA16_0>='0' && LA16_0<='9')||(LA16_0>='A' && LA16_0<='Z')||LA16_0=='_'||(LA16_0>='a' && LA16_0<='z')) ) { + alt16=1; + } + + + switch (alt16) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop16; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NAME" + + // $ANTLR start "STRING" + public final void mSTRING() throws RecognitionException { + try { + int _type = STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:5: ( ( 'r' | 'u' | 'b' | 'ur' | 'br' | 'R' | 'U' | 'B' | 'UR' | 'BR' | 'uR' | 'Ur' | 'Br' | 'bR' )? ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:9: ( 'r' | 'u' | 'b' | 'ur' | 'br' | 'R' | 'U' | 'B' | 'UR' | 'BR' | 'uR' | 'Ur' | 'Br' | 'bR' )? ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:9: ( 'r' | 'u' | 'b' | 'ur' | 'br' | 'R' | 'U' | 'B' | 'UR' | 'BR' | 'uR' | 'Ur' | 'Br' | 'bR' )? + int alt17=15; + alt17 = dfa17.predict(input); + switch (alt17) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:10: 'r' + { + match('r'); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:14: 'u' + { + match('u'); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:18: 'b' + { + match('b'); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:22: 'ur' + { + match("ur"); + + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:27: 'br' + { + match("br"); + + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:32: 'R' + { + match('R'); + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:36: 'U' + { + match('U'); + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:40: 'B' + { + match('B'); + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:44: 'UR' + { + match("UR"); + + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:49: 'BR' + { + match("BR"); + + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:54: 'uR' + { + match("uR"); + + + } + break; + case 12 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:59: 'Ur' + { + match("Ur"); + + + } + break; + case 13 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:64: 'Br' + { + match("Br"); + + + } + break; + case 14 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2373:69: 'bR' + { + match("bR"); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2374:9: ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) + int alt22=4; + int LA22_0 = input.LA(1); + + if ( (LA22_0=='\'') ) { + int LA22_1 = input.LA(2); + + if ( (LA22_1=='\'') ) { + int LA22_3 = input.LA(3); + + if ( (LA22_3=='\'') ) { + alt22=1; + } + else { + alt22=4;} + } + else if ( ((LA22_1>='\u0000' && LA22_1<='\t')||(LA22_1>='\u000B' && LA22_1<='&')||(LA22_1>='(' && LA22_1<='\uFFFF')) ) { + alt22=4; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 22, 1, input); + + throw nvae; + } + } + else if ( (LA22_0=='\"') ) { + int LA22_2 = input.LA(2); + + if ( (LA22_2=='\"') ) { + int LA22_5 = input.LA(3); + + if ( (LA22_5=='\"') ) { + alt22=2; + } + else { + alt22=3;} + } + else if ( ((LA22_2>='\u0000' && LA22_2<='\t')||(LA22_2>='\u000B' && LA22_2<='!')||(LA22_2>='#' && LA22_2<='\uFFFF')) ) { + alt22=3; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 22, 2, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + + throw nvae; + } + switch (alt22) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2374:13: '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' + { + match("'''"); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2374:22: ( options {greedy=false; } : TRIAPOS )* + loop18: + do { + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0=='\'') ) { + int LA18_1 = input.LA(2); + + if ( (LA18_1=='\'') ) { + int LA18_3 = input.LA(3); + + if ( (LA18_3=='\'') ) { + alt18=2; + } + else if ( ((LA18_3>='\u0000' && LA18_3<='&')||(LA18_3>='(' && LA18_3<='\uFFFF')) ) { + alt18=1; + } + + + } + else if ( ((LA18_1>='\u0000' && LA18_1<='&')||(LA18_1>='(' && LA18_1<='\uFFFF')) ) { + alt18=1; + } + + + } + else if ( ((LA18_0>='\u0000' && LA18_0<='&')||(LA18_0>='(' && LA18_0<='\uFFFF')) ) { + alt18=1; + } + + + switch (alt18) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2374:47: TRIAPOS + { + mTRIAPOS(); + + } + break; + + default : + break loop18; + } + } while (true); + + match("'''"); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2375:13: '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' + { + match("\"\"\""); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2375:19: ( options {greedy=false; } : TRIQUOTE )* + loop19: + do { + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0=='\"') ) { + int LA19_1 = input.LA(2); + + if ( (LA19_1=='\"') ) { + int LA19_3 = input.LA(3); + + if ( (LA19_3=='\"') ) { + alt19=2; + } + else if ( ((LA19_3>='\u0000' && LA19_3<='!')||(LA19_3>='#' && LA19_3<='\uFFFF')) ) { + alt19=1; + } + + + } + else if ( ((LA19_1>='\u0000' && LA19_1<='!')||(LA19_1>='#' && LA19_1<='\uFFFF')) ) { + alt19=1; + } + + + } + else if ( ((LA19_0>='\u0000' && LA19_0<='!')||(LA19_0>='#' && LA19_0<='\uFFFF')) ) { + alt19=1; + } + + + switch (alt19) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2375:44: TRIQUOTE + { + mTRIQUOTE(); + + } + break; + + default : + break loop19; + } + } while (true); + + match("\"\"\""); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2376:13: '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' + { + match('\"'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2376:17: ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* + loop20: + do { + int alt20=3; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='\\') ) { + alt20=1; + } + else if ( ((LA20_0>='\u0000' && LA20_0<='\t')||(LA20_0>='\u000B' && LA20_0<='!')||(LA20_0>='#' && LA20_0<='[')||(LA20_0>=']' && LA20_0<='\uFFFF')) ) { + alt20=2; + } + + + switch (alt20) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2376:18: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2376:22: ~ ( '\\\\' | '\\n' | '\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop20; + } + } while (true); + + match('\"'); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2377:13: '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' + { + match('\''); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2377:18: ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* + loop21: + do { + int alt21=3; + int LA21_0 = input.LA(1); + + if ( (LA21_0=='\\') ) { + alt21=1; + } + else if ( ((LA21_0>='\u0000' && LA21_0<='\t')||(LA21_0>='\u000B' && LA21_0<='&')||(LA21_0>='(' && LA21_0<='[')||(LA21_0>=']' && LA21_0<='\uFFFF')) ) { + alt21=2; + } + + + switch (alt21) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2377:19: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2377:23: ~ ( '\\\\' | '\\n' | '\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop21; + } + } while (true); + + match('\''); + + } + break; + + } + + + if (state.tokenStartLine != input.getLine()) { + state.tokenStartLine = input.getLine(); + state.tokenStartCharPositionInLine = -2; + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STRING" + + // $ANTLR start "TRIQUOTE" + public final void mTRIQUOTE() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:5: ( ( '\"' )? ( '\"' )? ( ESC | ~ ( '\\\\' | '\"' ) )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:7: ( '\"' )? ( '\"' )? ( ESC | ~ ( '\\\\' | '\"' ) )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:7: ( '\"' )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\"') ) { + alt23=1; + } + switch (alt23) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:7: '\"' + { + match('\"'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:12: ( '\"' )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\"') ) { + alt24=1; + } + switch (alt24) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:12: '\"' + { + match('\"'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:17: ( ESC | ~ ( '\\\\' | '\"' ) )+ + int cnt25=0; + loop25: + do { + int alt25=3; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\\') ) { + alt25=1; + } + else if ( ((LA25_0>='\u0000' && LA25_0<='!')||(LA25_0>='#' && LA25_0<='[')||(LA25_0>=']' && LA25_0<='\uFFFF')) ) { + alt25=2; + } + + + switch (alt25) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:18: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2389:22: ~ ( '\\\\' | '\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt25 >= 1 ) break loop25; + EarlyExitException eee = + new EarlyExitException(25, input); + throw eee; + } + cnt25++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "TRIQUOTE" + + // $ANTLR start "TRIAPOS" + public final void mTRIAPOS() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:5: ( ( '\\'' )? ( '\\'' )? ( ESC | ~ ( '\\\\' | '\\'' ) )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:7: ( '\\'' )? ( '\\'' )? ( ESC | ~ ( '\\\\' | '\\'' ) )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:7: ( '\\'' )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='\'') ) { + alt26=1; + } + switch (alt26) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:7: '\\'' + { + match('\''); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:13: ( '\\'' )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0=='\'') ) { + alt27=1; + } + switch (alt27) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:13: '\\'' + { + match('\''); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:19: ( ESC | ~ ( '\\\\' | '\\'' ) )+ + int cnt28=0; + loop28: + do { + int alt28=3; + int LA28_0 = input.LA(1); + + if ( (LA28_0=='\\') ) { + alt28=1; + } + else if ( ((LA28_0>='\u0000' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='[')||(LA28_0>=']' && LA28_0<='\uFFFF')) ) { + alt28=2; + } + + + switch (alt28) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:20: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2395:24: ~ ( '\\\\' | '\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt28 >= 1 ) break loop28; + EarlyExitException eee = + new EarlyExitException(28, input); + throw eee; + } + cnt28++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "TRIAPOS" + + // $ANTLR start "ESC" + public final void mESC() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2400:5: ( '\\\\' . ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2400:10: '\\\\' . + { + match('\\'); + matchAny(); + + } + + } + finally { + } + } + // $ANTLR end "ESC" + + // $ANTLR start "CONTINUED_LINE" + public final void mCONTINUED_LINE() throws RecognitionException { + try { + int _type = CONTINUED_LINE; + int _channel = DEFAULT_TOKEN_CHANNEL; + Token nl=null; + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2408:5: ( '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )* ( COMMENT | nl= NEWLINE | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2408:10: '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )* ( COMMENT | nl= NEWLINE | ) + { + match('\\'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2408:15: ( '\\r' )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0=='\r') ) { + alt29=1; + } + switch (alt29) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2408:16: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2408:28: ( ' ' | '\\t' )* + loop30: + do { + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0=='\t'||LA30_0==' ') ) { + alt30=1; + } + + + switch (alt30) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop30; + } + } while (true); + + _channel=HIDDEN; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2409:10: ( COMMENT | nl= NEWLINE | ) + int alt31=3; + int LA31_0 = input.LA(1); + + if ( (LA31_0=='\t'||LA31_0==' ') && ((startPos==0))) { + alt31=1; + } + else if ( (LA31_0=='#') ) { + alt31=1; + } + else if ( (LA31_0=='\n'||(LA31_0>='\f' && LA31_0<='\r')) ) { + alt31=2; + } + else { + alt31=3;} + switch (alt31) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2409:12: COMMENT + { + mCOMMENT(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2410:12: nl= NEWLINE + { + int nlStart1805 = getCharIndex(); + mNEWLINE(); + nl = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, nlStart1805, getCharIndex()-1); + + emit(new CommonToken(NEWLINE,nl.getText())); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2415:10: + { + } + break; + + } + + + if (input.LA(1) == -1) { + throw new ParseException("unexpected character after line continuation character"); + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CONTINUED_LINE" + + // $ANTLR start "NEWLINE" + public final void mNEWLINE() throws RecognitionException { + try { + int _type = NEWLINE; + int _channel = DEFAULT_TOKEN_CHANNEL; + + int newlines = 0; + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:5: ( ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:9: ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:9: ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ + int cnt34=0; + loop34: + do { + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0=='\n'||(LA34_0>='\f' && LA34_0<='\r')) ) { + alt34=1; + } + + + switch (alt34) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:10: ( '\\u000C' )? ( '\\r' )? '\\n' + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:10: ( '\\u000C' )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0=='\f') ) { + alt32=1; + } + switch (alt32) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:11: '\\u000C' + { + match('\f'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:21: ( '\\r' )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0=='\r') ) { + alt33=1; + } + switch (alt33) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2432:22: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + newlines++; + + } + break; + + default : + if ( cnt34 >= 1 ) break loop34; + EarlyExitException eee = + new EarlyExitException(34, input); + throw eee; + } + cnt34++; + } while (true); + + + if ( startPos==0 || implicitLineJoiningLevel>0 ) + _channel=HIDDEN; + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NEWLINE" + + // $ANTLR start "WS" + public final void mWS() throws RecognitionException { + try { + int _type = WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2438:5: ({...}? => ( ' ' | '\\t' | '\\u000C' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2438:10: {...}? => ( ' ' | '\\t' | '\\u000C' )+ + { + if ( !((startPos>0)) ) { + throw new FailedPredicateException(input, "WS", "startPos>0"); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2438:26: ( ' ' | '\\t' | '\\u000C' )+ + int cnt35=0; + loop35: + do { + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0=='\t'||LA35_0=='\f'||LA35_0==' ') ) { + alt35=1; + } + + + switch (alt35) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( input.LA(1)=='\t'||input.LA(1)=='\f'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt35 >= 1 ) break loop35; + EarlyExitException eee = + new EarlyExitException(35, input); + throw eee; + } + cnt35++; + } while (true); + + _channel=HIDDEN; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WS" + + // $ANTLR start "LEADING_WS" + public final void mLEADING_WS() throws RecognitionException { + try { + int _type = LEADING_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + + int spaces = 0; + int newlines = 0; + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2452:5: ({...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2452:9: {...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) + { + if ( !((startPos==0)) ) { + throw new FailedPredicateException(input, "LEADING_WS", "startPos==0"); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2453:9: ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==' ') ) { + int LA40_1 = input.LA(2); + + if ( ((implicitLineJoiningLevel>0)) ) { + alt40=1; + } + else if ( (true) ) { + alt40=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 40, 1, input); + + throw nvae; + } + } + else if ( (LA40_0=='\t') ) { + int LA40_2 = input.LA(2); + + if ( ((implicitLineJoiningLevel>0)) ) { + alt40=1; + } + else if ( (true) ) { + alt40=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 40, 2, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); + + throw nvae; + } + switch (alt40) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2453:13: {...}? ( ' ' | '\\t' )+ + { + if ( !((implicitLineJoiningLevel>0)) ) { + throw new FailedPredicateException(input, "LEADING_WS", "implicitLineJoiningLevel>0"); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2453:43: ( ' ' | '\\t' )+ + int cnt36=0; + loop36: + do { + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0=='\t'||LA36_0==' ') ) { + alt36=1; + } + + + switch (alt36) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt36 >= 1 ) break loop36; + EarlyExitException eee = + new EarlyExitException(36, input); + throw eee; + } + cnt36++; + } while (true); + + _channel=HIDDEN; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2454:14: ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2454:14: ( ' ' | '\\t' )+ + int cnt37=0; + loop37: + do { + int alt37=3; + int LA37_0 = input.LA(1); + + if ( (LA37_0==' ') ) { + alt37=1; + } + else if ( (LA37_0=='\t') ) { + alt37=2; + } + + + switch (alt37) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2454:20: ' ' + { + match(' '); + spaces++; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2455:19: '\\t' + { + match('\t'); + spaces += 8; spaces -= (spaces % 8); + + } + break; + + default : + if ( cnt37 >= 1 ) break loop37; + EarlyExitException eee = + new EarlyExitException(37, input); + throw eee; + } + cnt37++; + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2457:14: ( ( '\\r' )? '\\n' )* + loop39: + do { + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0=='\n'||LA39_0=='\r') ) { + alt39=1; + } + + + switch (alt39) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2457:16: ( '\\r' )? '\\n' + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2457:16: ( '\\r' )? + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0=='\r') ) { + alt38=1; + } + switch (alt38) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2457:17: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + newlines++; + + } + break; + + default : + break loop39; + } + } while (true); + + + if (input.LA(1) != -1 || newlines == 0) { + // make a string of n spaces where n is column number - 1 + char[] indentation = new char[spaces]; + for (int i=0; i + // + // The above would complete in interactive mode instead + // of giving ... to wait for more input. + // + throw new ParseException("Trailing space in single mode."); + } else { + // make a string of n newlines + char[] nls = new char[newlines]; + for (int i=0; i ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ | '#' (~ '\\n' )* ) + int alt45=2; + alt45 = dfa45.predict(input); + switch (alt45) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:10: {...}? => ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ + { + if ( !((startPos==0)) ) { + throw new FailedPredicateException(input, "COMMENT", "startPos==0"); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:27: ( ' ' | '\\t' )* + loop41: + do { + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0=='\t'||LA41_0==' ') ) { + alt41=1; + } + + + switch (alt41) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop41; + } + } while (true); + + match('#'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:43: (~ '\\n' )* + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); + + if ( ((LA42_0>='\u0000' && LA42_0<='\t')||(LA42_0>='\u000B' && LA42_0<='\uFFFF')) ) { + alt42=1; + } + + + switch (alt42) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:44: ~ '\\n' + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop42; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:52: ( '\\n' )+ + int cnt43=0; + loop43: + do { + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0=='\n') ) { + alt43=1; + } + + + switch (alt43) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2528:52: '\\n' + { + match('\n'); + + } + break; + + default : + if ( cnt43 >= 1 ) break loop43; + EarlyExitException eee = + new EarlyExitException(43, input); + throw eee; + } + cnt43++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2529:10: '#' (~ '\\n' )* + { + match('#'); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2529:14: (~ '\\n' )* + loop44: + do { + int alt44=2; + int LA44_0 = input.LA(1); + + if ( ((LA44_0>='\u0000' && LA44_0<='\t')||(LA44_0>='\u000B' && LA44_0<='\uFFFF')) ) { + alt44=1; + } + + + switch (alt44) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2529:15: ~ '\\n' + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop44; + } + } while (true); + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMMENT" + + public void mTokens() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:8: ( AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD | LPAREN | RPAREN | LBRACK | RBRACK | COLON | COMMA | SEMI | PLUS | MINUS | STAR | SLASH | VBAR | AMPER | LESS | GREATER | ASSIGN | PERCENT | BACKQUOTE | LCURLY | RCURLY | CIRCUMFLEX | TILDE | EQUAL | NOTEQUAL | ALT_NOTEQUAL | LESSEQUAL | LEFTSHIFT | GREATEREQUAL | RIGHTSHIFT | PLUSEQUAL | MINUSEQUAL | DOUBLESTAR | STAREQUAL | DOUBLESLASH | SLASHEQUAL | VBAREQUAL | PERCENTEQUAL | AMPEREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL | DOT | AT | AND | OR | NOT | FLOAT | LONGINT | INT | COMPLEX | NAME | STRING | CONTINUED_LINE | NEWLINE | WS | LEADING_WS | COMMENT ) + int alt46=87; + alt46 = dfa46.predict(input); + switch (alt46) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:10: AS + { + mAS(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:13: ASSERT + { + mASSERT(); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:20: BREAK + { + mBREAK(); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:26: CLASS + { + mCLASS(); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:32: CONTINUE + { + mCONTINUE(); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:41: DEF + { + mDEF(); + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:45: DELETE + { + mDELETE(); + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:52: ELIF + { + mELIF(); + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:57: EXCEPT + { + mEXCEPT(); + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:64: EXEC + { + mEXEC(); + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:69: FINALLY + { + mFINALLY(); + + } + break; + case 12 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:77: FROM + { + mFROM(); + + } + break; + case 13 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:82: FOR + { + mFOR(); + + } + break; + case 14 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:86: GLOBAL + { + mGLOBAL(); + + } + break; + case 15 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:93: IF + { + mIF(); + + } + break; + case 16 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:96: IMPORT + { + mIMPORT(); + + } + break; + case 17 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:103: IN + { + mIN(); + + } + break; + case 18 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:106: IS + { + mIS(); + + } + break; + case 19 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:109: LAMBDA + { + mLAMBDA(); + + } + break; + case 20 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:116: ORELSE + { + mORELSE(); + + } + break; + case 21 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:123: PASS + { + mPASS(); + + } + break; + case 22 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:128: PRINT + { + mPRINT(); + + } + break; + case 23 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:134: RAISE + { + mRAISE(); + + } + break; + case 24 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:140: RETURN + { + mRETURN(); + + } + break; + case 25 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:147: TRY + { + mTRY(); + + } + break; + case 26 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:151: WHILE + { + mWHILE(); + + } + break; + case 27 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:157: WITH + { + mWITH(); + + } + break; + case 28 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:162: YIELD + { + mYIELD(); + + } + break; + case 29 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:168: LPAREN + { + mLPAREN(); + + } + break; + case 30 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:175: RPAREN + { + mRPAREN(); + + } + break; + case 31 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:182: LBRACK + { + mLBRACK(); + + } + break; + case 32 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:189: RBRACK + { + mRBRACK(); + + } + break; + case 33 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:196: COLON + { + mCOLON(); + + } + break; + case 34 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:202: COMMA + { + mCOMMA(); + + } + break; + case 35 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:208: SEMI + { + mSEMI(); + + } + break; + case 36 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:213: PLUS + { + mPLUS(); + + } + break; + case 37 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:218: MINUS + { + mMINUS(); + + } + break; + case 38 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:224: STAR + { + mSTAR(); + + } + break; + case 39 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:229: SLASH + { + mSLASH(); + + } + break; + case 40 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:235: VBAR + { + mVBAR(); + + } + break; + case 41 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:240: AMPER + { + mAMPER(); + + } + break; + case 42 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:246: LESS + { + mLESS(); + + } + break; + case 43 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:251: GREATER + { + mGREATER(); + + } + break; + case 44 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:259: ASSIGN + { + mASSIGN(); + + } + break; + case 45 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:266: PERCENT + { + mPERCENT(); + + } + break; + case 46 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:274: BACKQUOTE + { + mBACKQUOTE(); + + } + break; + case 47 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:284: LCURLY + { + mLCURLY(); + + } + break; + case 48 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:291: RCURLY + { + mRCURLY(); + + } + break; + case 49 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:298: CIRCUMFLEX + { + mCIRCUMFLEX(); + + } + break; + case 50 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:309: TILDE + { + mTILDE(); + + } + break; + case 51 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:315: EQUAL + { + mEQUAL(); + + } + break; + case 52 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:321: NOTEQUAL + { + mNOTEQUAL(); + + } + break; + case 53 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:330: ALT_NOTEQUAL + { + mALT_NOTEQUAL(); + + } + break; + case 54 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:343: LESSEQUAL + { + mLESSEQUAL(); + + } + break; + case 55 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:353: LEFTSHIFT + { + mLEFTSHIFT(); + + } + break; + case 56 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:363: GREATEREQUAL + { + mGREATEREQUAL(); + + } + break; + case 57 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:376: RIGHTSHIFT + { + mRIGHTSHIFT(); + + } + break; + case 58 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:387: PLUSEQUAL + { + mPLUSEQUAL(); + + } + break; + case 59 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:397: MINUSEQUAL + { + mMINUSEQUAL(); + + } + break; + case 60 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:408: DOUBLESTAR + { + mDOUBLESTAR(); + + } + break; + case 61 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:419: STAREQUAL + { + mSTAREQUAL(); + + } + break; + case 62 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:429: DOUBLESLASH + { + mDOUBLESLASH(); + + } + break; + case 63 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:441: SLASHEQUAL + { + mSLASHEQUAL(); + + } + break; + case 64 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:452: VBAREQUAL + { + mVBAREQUAL(); + + } + break; + case 65 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:462: PERCENTEQUAL + { + mPERCENTEQUAL(); + + } + break; + case 66 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:475: AMPEREQUAL + { + mAMPEREQUAL(); + + } + break; + case 67 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:486: CIRCUMFLEXEQUAL + { + mCIRCUMFLEXEQUAL(); + + } + break; + case 68 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:502: LEFTSHIFTEQUAL + { + mLEFTSHIFTEQUAL(); + + } + break; + case 69 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:517: RIGHTSHIFTEQUAL + { + mRIGHTSHIFTEQUAL(); + + } + break; + case 70 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:533: DOUBLESTAREQUAL + { + mDOUBLESTAREQUAL(); + + } + break; + case 71 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:549: DOUBLESLASHEQUAL + { + mDOUBLESLASHEQUAL(); + + } + break; + case 72 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:566: DOT + { + mDOT(); + + } + break; + case 73 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:570: AT + { + mAT(); + + } + break; + case 74 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:573: AND + { + mAND(); + + } + break; + case 75 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:577: OR + { + mOR(); + + } + break; + case 76 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:580: NOT + { + mNOT(); + + } + break; + case 77 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:584: FLOAT + { + mFLOAT(); + + } + break; + case 78 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:590: LONGINT + { + mLONGINT(); + + } + break; + case 79 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:598: INT + { + mINT(); + + } + break; + case 80 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:602: COMPLEX + { + mCOMPLEX(); + + } + break; + case 81 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:610: NAME + { + mNAME(); + + } + break; + case 82 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:615: STRING + { + mSTRING(); + + } + break; + case 83 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:622: CONTINUED_LINE + { + mCONTINUED_LINE(); + + } + break; + case 84 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:637: NEWLINE + { + mNEWLINE(); + + } + break; + case 85 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:645: WS + { + mWS(); + + } + break; + case 86 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:648: LEADING_WS + { + mLEADING_WS(); + + } + break; + case 87 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1:659: COMMENT + { + mCOMMENT(); + + } + break; + + } + + } + + + protected DFA5 dfa5 = new DFA5(this); + protected DFA14 dfa14 = new DFA14(this); + protected DFA17 dfa17 = new DFA17(this); + protected DFA45 dfa45 = new DFA45(this); + protected DFA46 dfa46 = new DFA46(this); + static final String DFA5_eotS = + "\3\uffff\1\4\2\uffff"; + static final String DFA5_eofS = + "\6\uffff"; + static final String DFA5_minS = + "\1\56\1\uffff\1\56\1\105\2\uffff"; + static final String DFA5_maxS = + "\1\71\1\uffff\2\145\2\uffff"; + static final String DFA5_acceptS = + "\1\uffff\1\1\2\uffff\1\3\1\2"; + static final String DFA5_specialS = + "\6\uffff}>"; + static final String[] DFA5_transitionS = { + "\1\1\1\uffff\12\2", + "", + "\1\3\1\uffff\12\2\13\uffff\1\4\37\uffff\1\4", + "\1\5\37\uffff\1\5", + "", + "" + }; + + static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS); + static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS); + static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS); + static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS); + static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS); + static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS); + static final short[][] DFA5_transition; + + static { + int numStates = DFA5_transitionS.length; + DFA5_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA14_transitionS = { + "\1\2\1\uffff\12\1", + "\1\2\1\uffff\12\1\13\uffff\1\2\4\uffff\1\3\32\uffff\1\2\4\uffff"+ + "\1\3", + "", + "" + }; + + static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); + static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); + static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); + static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); + static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); + static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); + static final short[][] DFA14_transition; + + static { + int numStates = DFA14_transitionS.length; + DFA14_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA17_transitionS = { + "\1\7\4\uffff\1\7\32\uffff\1\6\17\uffff\1\4\2\uffff\1\5\14\uffff"+ + "\1\3\17\uffff\1\1\2\uffff\1\2", + "", + "\1\12\4\uffff\1\12\52\uffff\1\11\37\uffff\1\10", + "\1\15\4\uffff\1\15\52\uffff\1\14\37\uffff\1\13", + "", + "\1\20\4\uffff\1\20\52\uffff\1\16\37\uffff\1\17", + "\1\23\4\uffff\1\23\52\uffff\1\21\37\uffff\1\22", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS); + static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS); + static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS); + static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS); + static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS); + static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS); + static final short[][] DFA17_transition; + + static { + int numStates = DFA17_transitionS.length; + DFA17_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA45_transitionS = { + "\1\1\26\uffff\1\1\2\uffff\1\2", + "", + "\12\3\1\1\ufff5\3", + "\12\3\1\1\ufff5\3", + "" + }; + + static final short[] DFA45_eot = DFA.unpackEncodedString(DFA45_eotS); + static final short[] DFA45_eof = DFA.unpackEncodedString(DFA45_eofS); + static final char[] DFA45_min = DFA.unpackEncodedStringToUnsignedChars(DFA45_minS); + static final char[] DFA45_max = DFA.unpackEncodedStringToUnsignedChars(DFA45_maxS); + static final short[] DFA45_accept = DFA.unpackEncodedString(DFA45_acceptS); + static final short[] DFA45_special = DFA.unpackEncodedString(DFA45_specialS); + static final short[][] DFA45_transition; + + static { + int numStates = DFA45_transitionS.length; + DFA45_transition = new short[numStates][]; + for (int i=0; i ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ | '#' (~ '\\n' )* );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + IntStream input = _input; + int _s = s; + switch ( s ) { + case 0 : + int LA45_0 = input.LA(1); + + + int index45_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA45_0=='\t'||LA45_0==' ') && ((startPos==0))) {s = 1;} + + else if ( (LA45_0=='#') ) {s = 2;} + + + input.seek(index45_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA45_3 = input.LA(1); + + + int index45_3 = input.index(); + input.rewind(); + s = -1; + if ( ((LA45_3>='\u0000' && LA45_3<='\t')||(LA45_3>='\u000B' && LA45_3<='\uFFFF')) ) {s = 3;} + + else if ( (LA45_3=='\n') && ((startPos==0))) {s = 1;} + + else s = 4; + + + input.seek(index45_3); + if ( s>=0 ) return s; + break; + case 2 : + int LA45_2 = input.LA(1); + + + int index45_2 = input.index(); + input.rewind(); + s = -1; + if ( ((LA45_2>='\u0000' && LA45_2<='\t')||(LA45_2>='\u000B' && LA45_2<='\uFFFF')) ) {s = 3;} + + else if ( (LA45_2=='\n') && ((startPos==0))) {s = 1;} + + else s = 4; + + + input.seek(index45_2); + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 45, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA46_eotS = + "\1\uffff\16\60\7\uffff\1\123\1\125\1\130\1\133\1\135\1\137\1\143"+ + "\1\146\1\150\1\152\3\uffff\1\154\2\uffff\1\156\1\uffff\2\60\2\165"+ + "\4\60\3\uffff\1\u0082\1\uffff\1\u0084\1\u0086\1\uffff\1\u0088\14"+ + "\60\1\u0097\1\60\1\u0099\1\u009a\11\60\4\uffff\1\u00a5\2\uffff\1"+ + "\u00a7\10\uffff\1\u00a9\2\uffff\1\u00ab\7\uffff\1\u00ac\1\uffff"+ + "\1\u00ae\1\60\1\uffff\3\165\2\uffff\1\u00ac\3\uffff\1\165\6\60\5"+ + "\uffff\1\60\1\uffff\1\u00b8\3\60\1\u00bc\1\u00bd\6\60\1\u00c4\1"+ + "\60\1\uffff\1\60\2\uffff\5\60\1\u00cc\3\60\13\uffff\1\u00d2\3\165"+ + "\1\u00ac\2\uffff\1\u00ac\1\60\1\uffff\3\60\2\uffff\1\u00da\1\u00db"+ + "\1\60\1\u00dd\1\60\1\u00df\1\uffff\3\60\1\u00e3\3\60\1\uffff\1\60"+ + "\1\u00e8\1\60\1\uffff\1\u00ac\3\uffff\1\u00ac\1\60\1\u00ed\1\u00ee"+ + "\1\60\2\uffff\1\60\1\uffff\1\60\1\uffff\3\60\1\uffff\1\u00f5\1\u00f6"+ + "\1\60\1\u00f8\1\uffff\1\u00f9\1\uffff\1\u00ac\1\u00fa\2\uffff\1"+ + "\60\1\u00fc\1\60\1\u00fe\1\u00ff\1\u0100\2\uffff\1\u0101\3\uffff"+ + "\1\60\1\uffff\1\u0103\4\uffff\1\u0104\2\uffff"; + static final String DFA46_eofS = + "\u0105\uffff"; + static final String DFA46_minS = + "\1\11\1\156\1\42\1\154\1\145\1\154\1\151\1\154\1\146\2\141\1\42"+ + "\1\162\1\150\1\151\7\uffff\2\75\1\52\1\57\2\75\1\74\3\75\3\uffff"+ + "\1\75\2\uffff\1\60\1\uffff\1\162\1\157\2\56\4\42\3\uffff\1\12\1"+ + "\uffff\2\11\1\uffff\1\60\1\144\2\42\1\141\1\156\1\146\1\151\1\143"+ + "\1\156\1\157\1\162\1\157\1\60\1\160\2\60\1\155\1\163\2\151\1\164"+ + "\1\171\1\151\1\164\1\145\4\uffff\1\75\2\uffff\1\75\10\uffff\1\75"+ + "\2\uffff\1\75\7\uffff\1\60\1\uffff\1\60\1\164\3\60\1\56\2\uffff"+ + "\1\60\1\56\1\53\1\uffff\1\56\6\42\2\uffff\1\0\1\uffff\1\0\1\145"+ + "\1\uffff\1\60\1\141\1\163\1\164\2\60\1\146\2\145\1\143\1\141\1\155"+ + "\1\60\1\142\1\uffff\1\157\2\uffff\1\142\1\163\1\156\1\163\1\165"+ + "\1\60\1\154\1\150\1\154\11\uffff\1\53\1\uffff\5\60\1\53\2\60\1\162"+ + "\1\uffff\1\153\1\163\1\151\2\uffff\2\60\1\160\1\60\1\154\1\60\1"+ + "\uffff\1\141\1\162\1\144\1\60\1\164\1\145\1\162\1\uffff\1\145\1"+ + "\60\1\144\2\60\1\uffff\1\53\2\60\1\164\2\60\1\156\2\uffff\1\164"+ + "\1\uffff\1\154\1\uffff\1\154\1\164\1\141\1\uffff\2\60\1\156\1\60"+ + "\1\uffff\4\60\2\uffff\1\165\1\60\1\171\3\60\2\uffff\1\60\3\uffff"+ + "\1\145\1\uffff\1\60\4\uffff\1\60\2\uffff"; + static final String DFA46_maxS = + "\1\176\1\163\1\162\1\157\1\145\1\170\1\162\1\154\1\163\1\141\1\162"+ + "\1\145\1\162\2\151\7\uffff\6\75\2\76\2\75\3\uffff\1\75\2\uffff\1"+ + "\71\1\uffff\1\162\1\157\1\170\1\154\1\162\1\47\2\162\3\uffff\1\15"+ + "\1\uffff\2\43\1\uffff\1\172\1\144\1\145\1\47\1\141\1\156\1\154\1"+ + "\163\1\145\1\156\1\157\1\162\1\157\1\172\1\160\2\172\1\155\1\163"+ + "\2\151\1\164\1\171\1\151\1\164\1\145\4\uffff\1\75\2\uffff\1\75\10"+ + "\uffff\1\75\2\uffff\1\75\7\uffff\1\152\1\uffff\1\172\1\164\1\146"+ + "\3\154\2\uffff\2\152\1\71\1\uffff\1\154\6\47\2\uffff\1\0\1\uffff"+ + "\1\0\1\145\1\uffff\1\172\1\141\1\163\1\164\2\172\1\146\2\145\1\143"+ + "\1\141\1\155\1\172\1\142\1\uffff\1\157\2\uffff\1\142\1\163\1\156"+ + "\1\163\1\165\1\172\1\154\1\150\1\154\11\uffff\1\71\1\uffff\1\172"+ + "\3\154\1\152\2\71\1\152\1\162\1\uffff\1\153\1\163\1\151\2\uffff"+ + "\2\172\1\160\1\172\1\154\1\172\1\uffff\1\141\1\162\1\144\1\172\1"+ + "\164\1\145\1\162\1\uffff\1\145\1\172\1\144\1\71\1\152\1\uffff\2"+ + "\71\1\152\1\164\2\172\1\156\2\uffff\1\164\1\uffff\1\154\1\uffff"+ + "\1\154\1\164\1\141\1\uffff\2\172\1\156\1\172\1\uffff\1\172\1\71"+ + "\1\152\1\172\2\uffff\1\165\1\172\1\171\3\172\2\uffff\1\172\3\uffff"+ + "\1\145\1\uffff\1\172\4\uffff\1\172\2\uffff"; + static final String DFA46_acceptS = + "\17\uffff\1\35\1\36\1\37\1\40\1\41\1\42\1\43\12\uffff\1\56\1\57"+ + "\1\60\1\uffff\1\62\1\64\1\uffff\1\111\10\uffff\1\121\1\122\1\123"+ + "\1\uffff\1\124\2\uffff\1\127\32\uffff\1\72\1\44\1\73\1\45\1\uffff"+ + "\1\75\1\46\1\uffff\1\77\1\47\1\100\1\50\1\102\1\51\1\65\1\66\1\uffff"+ + "\1\52\1\70\1\uffff\1\53\1\63\1\54\1\101\1\55\1\103\1\61\1\uffff"+ + "\1\110\6\uffff\1\117\1\116\3\uffff\1\120\7\uffff\1\125\1\126\1\uffff"+ + "\1\127\2\uffff\1\1\16\uffff\1\17\1\uffff\1\21\1\22\11\uffff\1\106"+ + "\1\74\1\107\1\76\1\104\1\67\1\105\1\71\1\115\1\uffff\1\113\11\uffff"+ + "\1\112\3\uffff\1\6\1\7\6\uffff\1\15\7\uffff\1\31\5\uffff\1\114\7"+ + "\uffff\1\10\1\24\1\uffff\1\12\1\uffff\1\14\3\uffff\1\25\4\uffff"+ + "\1\33\4\uffff\1\3\1\4\6\uffff\1\26\1\27\1\uffff\1\32\1\34\1\2\1"+ + "\uffff\1\11\1\uffff\1\16\1\20\1\23\1\30\1\uffff\1\13\1\5"; + static final String DFA46_specialS = + "\1\1\62\uffff\1\0\1\uffff\1\4\1\5\115\uffff\1\2\1\uffff\1\3\176"+ + "\uffff}>"; + static final String[] DFA46_transitionS = { + "\1\66\1\64\1\uffff\1\63\1\64\22\uffff\1\65\1\45\1\61\1\67\1"+ + "\uffff\1\37\1\33\1\61\1\17\1\20\1\30\1\26\1\24\1\27\1\46\1\31"+ + "\1\52\11\53\1\23\1\25\1\34\1\36\1\35\1\uffff\1\47\1\60\1\57"+ + "\17\60\1\55\2\60\1\56\5\60\1\21\1\62\1\22\1\43\1\60\1\40\1\1"+ + "\1\2\1\3\1\4\1\5\1\6\1\7\1\60\1\10\2\60\1\11\1\60\1\51\1\50"+ + "\1\12\1\60\1\13\1\60\1\14\1\54\1\60\1\15\1\60\1\16\1\60\1\41"+ + "\1\32\1\42\1\44", + "\1\71\4\uffff\1\70", + "\1\61\4\uffff\1\61\52\uffff\1\73\37\uffff\1\72", + "\1\74\2\uffff\1\75", + "\1\76", + "\1\77\13\uffff\1\100", + "\1\101\5\uffff\1\103\2\uffff\1\102", + "\1\104", + "\1\105\6\uffff\1\106\1\107\4\uffff\1\110", + "\1\111", + "\1\112\20\uffff\1\113", + "\1\61\4\uffff\1\61\71\uffff\1\114\3\uffff\1\115", + "\1\116", + "\1\117\1\120", + "\1\121", + "", + "", + "", + "", + "", + "", + "", + "\1\122", + "\1\124", + "\1\126\22\uffff\1\127", + "\1\131\15\uffff\1\132", + "\1\134", + "\1\136", + "\1\142\1\141\1\140", + "\1\144\1\145", + "\1\147", + "\1\151", + "", + "", + "", + "\1\153", + "", + "", + "\12\155", + "", + "\1\157", + "\1\160", + "\1\167\1\uffff\10\164\2\170\10\uffff\1\163\2\uffff\1\171\4"+ + "\uffff\1\172\1\uffff\1\166\2\uffff\1\162\10\uffff\1\161\11\uffff"+ + "\1\163\2\uffff\1\171\4\uffff\1\172\1\uffff\1\166\2\uffff\1\162"+ + "\10\uffff\1\161", + "\1\167\1\uffff\12\173\13\uffff\1\171\4\uffff\1\172\1\uffff"+ + "\1\166\30\uffff\1\171\4\uffff\1\172\1\uffff\1\166", + "\1\61\4\uffff\1\61\52\uffff\1\175\37\uffff\1\174", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61\52\uffff\1\176\37\uffff\1\177", + "\1\61\4\uffff\1\61\52\uffff\1\u0080\37\uffff\1\u0081", + "", + "", + "", + "\1\64\2\uffff\1\64", + "", + "\1\66\1\u0083\1\uffff\1\u0082\1\u0083\22\uffff\1\65\2\uffff"+ + "\1\u0085", + "\1\66\1\u0083\1\uffff\1\u0082\1\u0083\22\uffff\1\65\2\uffff"+ + "\1\u0085", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\22\60\1\u0087\7\60", + "\1\u0089", + "\1\61\4\uffff\1\61\75\uffff\1\u008a", + "\1\61\4\uffff\1\61", + "\1\u008b", + "\1\u008c", + "\1\u008d\5\uffff\1\u008e", + "\1\u008f\11\uffff\1\u0090", + "\1\u0091\1\uffff\1\u0092", + "\1\u0093", + "\1\u0094", + "\1\u0095", + "\1\u0096", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u0098", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u009b", + "\1\u009c", + "\1\u009d", + "\1\u009e", + "\1\u009f", + "\1\u00a0", + "\1\u00a1", + "\1\u00a2", + "\1\u00a3", + "", + "", + "", + "", + "\1\u00a4", + "", + "", + "\1\u00a6", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\u00a8", + "", + "", + "\1\u00aa", + "", + "", + "", + "", + "", + "", + "", + "\12\155\13\uffff\1\u00ad\4\uffff\1\172\32\uffff\1\u00ad\4\uffff"+ + "\1\172", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00af", + "\12\u00b0\7\uffff\6\u00b0\32\uffff\6\u00b0", + "\10\u00b1\24\uffff\1\166\37\uffff\1\166", + "\2\u00b2\32\uffff\1\166\37\uffff\1\166", + "\1\167\1\uffff\10\164\2\170\13\uffff\1\171\4\uffff\1\172\1"+ + "\uffff\1\166\30\uffff\1\171\4\uffff\1\172\1\uffff\1\166", + "", + "", + "\12\u00b3\13\uffff\1\u00b4\4\uffff\1\172\32\uffff\1\u00b4\4"+ + "\uffff\1\172", + "\1\167\1\uffff\12\170\13\uffff\1\171\4\uffff\1\172\32\uffff"+ + "\1\171\4\uffff\1\172", + "\1\u00b5\1\uffff\1\u00b5\2\uffff\12\u00b6", + "", + "\1\167\1\uffff\12\173\13\uffff\1\171\4\uffff\1\172\1\uffff"+ + "\1\166\30\uffff\1\171\4\uffff\1\172\1\uffff\1\166", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61", + "\1\61\4\uffff\1\61", + "", + "", + "\1\uffff", + "", + "\1\uffff", + "\1\u00b7", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00b9", + "\1\u00ba", + "\1\u00bb", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00be", + "\1\u00bf", + "\1\u00c0", + "\1\u00c1", + "\1\u00c2", + "\1\u00c3", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00c5", + "", + "\1\u00c6", + "", + "", + "\1\u00c7", + "\1\u00c8", + "\1\u00c9", + "\1\u00ca", + "\1\u00cb", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00cd", + "\1\u00ce", + "\1\u00cf", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\u00d0\1\uffff\1\u00d0\2\uffff\12\u00d1", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\u00b0\7\uffff\6\u00b0\5\uffff\1\166\24\uffff\6\u00b0\5"+ + "\uffff\1\166", + "\10\u00b1\24\uffff\1\166\37\uffff\1\166", + "\2\u00b2\32\uffff\1\166\37\uffff\1\166", + "\12\u00b3\13\uffff\1\u00d3\4\uffff\1\172\32\uffff\1\u00d3\4"+ + "\uffff\1\172", + "\1\u00d4\1\uffff\1\u00d4\2\uffff\12\u00d5", + "\12\u00b6", + "\12\u00b6\20\uffff\1\172\37\uffff\1\172", + "\1\u00d6", + "", + "\1\u00d7", + "\1\u00d8", + "\1\u00d9", + "", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00dc", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00de", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "\1\u00e0", + "\1\u00e1", + "\1\u00e2", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00e4", + "\1\u00e5", + "\1\u00e6", + "", + "\1\u00e7", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00e9", + "\12\u00d1", + "\12\u00d1\20\uffff\1\172\37\uffff\1\172", + "", + "\1\u00ea\1\uffff\1\u00ea\2\uffff\12\u00eb", + "\12\u00d5", + "\12\u00d5\20\uffff\1\172\37\uffff\1\172", + "\1\u00ec", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00ef", + "", + "", + "\1\u00f0", + "", + "\1\u00f1", + "", + "\1\u00f2", + "\1\u00f3", + "\1\u00f4", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00f7", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\u00eb", + "\12\u00eb\20\uffff\1\172\37\uffff\1\172", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "", + "\1\u00fb", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\1\u00fd", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "", + "", + "\1\u0102", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "", + "", + "", + "\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60", + "", + "" + }; + + static final short[] DFA46_eot = DFA.unpackEncodedString(DFA46_eotS); + static final short[] DFA46_eof = DFA.unpackEncodedString(DFA46_eofS); + static final char[] DFA46_min = DFA.unpackEncodedStringToUnsignedChars(DFA46_minS); + static final char[] DFA46_max = DFA.unpackEncodedStringToUnsignedChars(DFA46_maxS); + static final short[] DFA46_accept = DFA.unpackEncodedString(DFA46_acceptS); + static final short[] DFA46_special = DFA.unpackEncodedString(DFA46_specialS); + static final short[][] DFA46_transition; + + static { + int numStates = DFA46_transitionS.length; + DFA46_transition = new short[numStates][]; + for (int i=0; i=0 ) return s; + break; + case 1 : + int LA46_0 = input.LA(1); + + + int index46_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA46_0=='a') ) {s = 1;} + + else if ( (LA46_0=='b') ) {s = 2;} + + else if ( (LA46_0=='c') ) {s = 3;} + + else if ( (LA46_0=='d') ) {s = 4;} + + else if ( (LA46_0=='e') ) {s = 5;} + + else if ( (LA46_0=='f') ) {s = 6;} + + else if ( (LA46_0=='g') ) {s = 7;} + + else if ( (LA46_0=='i') ) {s = 8;} + + else if ( (LA46_0=='l') ) {s = 9;} + + else if ( (LA46_0=='p') ) {s = 10;} + + else if ( (LA46_0=='r') ) {s = 11;} + + else if ( (LA46_0=='t') ) {s = 12;} + + else if ( (LA46_0=='w') ) {s = 13;} + + else if ( (LA46_0=='y') ) {s = 14;} + + else if ( (LA46_0=='(') ) {s = 15;} + + else if ( (LA46_0==')') ) {s = 16;} + + else if ( (LA46_0=='[') ) {s = 17;} + + else if ( (LA46_0==']') ) {s = 18;} + + else if ( (LA46_0==':') ) {s = 19;} + + else if ( (LA46_0==',') ) {s = 20;} + + else if ( (LA46_0==';') ) {s = 21;} + + else if ( (LA46_0=='+') ) {s = 22;} + + else if ( (LA46_0=='-') ) {s = 23;} + + else if ( (LA46_0=='*') ) {s = 24;} + + else if ( (LA46_0=='/') ) {s = 25;} + + else if ( (LA46_0=='|') ) {s = 26;} + + else if ( (LA46_0=='&') ) {s = 27;} + + else if ( (LA46_0=='<') ) {s = 28;} + + else if ( (LA46_0=='>') ) {s = 29;} + + else if ( (LA46_0=='=') ) {s = 30;} + + else if ( (LA46_0=='%') ) {s = 31;} + + else if ( (LA46_0=='`') ) {s = 32;} + + else if ( (LA46_0=='{') ) {s = 33;} + + else if ( (LA46_0=='}') ) {s = 34;} + + else if ( (LA46_0=='^') ) {s = 35;} + + else if ( (LA46_0=='~') ) {s = 36;} + + else if ( (LA46_0=='!') ) {s = 37;} + + else if ( (LA46_0=='.') ) {s = 38;} + + else if ( (LA46_0=='@') ) {s = 39;} + + else if ( (LA46_0=='o') ) {s = 40;} + + else if ( (LA46_0=='n') ) {s = 41;} + + else if ( (LA46_0=='0') ) {s = 42;} + + else if ( ((LA46_0>='1' && LA46_0<='9')) ) {s = 43;} + + else if ( (LA46_0=='u') ) {s = 44;} + + else if ( (LA46_0=='R') ) {s = 45;} + + else if ( (LA46_0=='U') ) {s = 46;} + + else if ( (LA46_0=='B') ) {s = 47;} + + else if ( (LA46_0=='A'||(LA46_0>='C' && LA46_0<='Q')||(LA46_0>='S' && LA46_0<='T')||(LA46_0>='V' && LA46_0<='Z')||LA46_0=='_'||LA46_0=='h'||(LA46_0>='j' && LA46_0<='k')||LA46_0=='m'||LA46_0=='q'||LA46_0=='s'||LA46_0=='v'||LA46_0=='x'||LA46_0=='z') ) {s = 48;} + + else if ( (LA46_0=='\"'||LA46_0=='\'') ) {s = 49;} + + else if ( (LA46_0=='\\') ) {s = 50;} + + else if ( (LA46_0=='\f') ) {s = 51;} + + else if ( (LA46_0=='\n'||LA46_0=='\r') ) {s = 52;} + + else if ( (LA46_0==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA46_0=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else if ( (LA46_0=='#') ) {s = 55;} + + + input.seek(index46_0); + if ( s>=0 ) return s; + break; + case 2 : + int LA46_132 = input.LA(1); + + + int index46_132 = input.index(); + input.rewind(); + s = -1; + if ( ((startPos>0)) ) {s = 130;} + + else if ( (((startPos==0)||((startPos==0)&&(implicitLineJoiningLevel>0)))) ) {s = 131;} + + + input.seek(index46_132); + if ( s>=0 ) return s; + break; + case 3 : + int LA46_134 = input.LA(1); + + + int index46_134 = input.index(); + input.rewind(); + s = -1; + if ( ((startPos>0)) ) {s = 130;} + + else if ( (((startPos==0)||((startPos==0)&&(implicitLineJoiningLevel>0)))) ) {s = 131;} + + + input.seek(index46_134); + if ( s>=0 ) return s; + break; + case 4 : + int LA46_53 = input.LA(1); + + + int index46_53 = input.index(); + input.rewind(); + s = -1; + if ( (LA46_53=='\n'||LA46_53=='\r') && ((startPos==0))) {s = 131;} + + else if ( (LA46_53==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA46_53=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else if ( (LA46_53=='#') && ((startPos==0))) {s = 133;} + + else if ( (LA46_53=='\f') && ((startPos>0))) {s = 130;} + + else s = 132; + + + input.seek(index46_53); + if ( s>=0 ) return s; + break; + case 5 : + int LA46_54 = input.LA(1); + + + int index46_54 = input.index(); + input.rewind(); + s = -1; + if ( (LA46_54=='\n'||LA46_54=='\r') && ((startPos==0))) {s = 131;} + + else if ( (LA46_54==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA46_54=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else if ( (LA46_54=='#') && ((startPos==0))) {s = 133;} + + else if ( (LA46_54=='\f') && ((startPos>0))) {s = 130;} + + else s = 134; + + + input.seek(index46_54); + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 46, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/gensrc/org/python/antlr/PythonParser.java b/gensrc/org/python/antlr/PythonParser.java new file mode 100644 index 000000000..44b268f5a --- /dev/null +++ b/gensrc/org/python/antlr/PythonParser.java @@ -0,0 +1,18644 @@ +// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 /Users/orion.moore/apps/code/jython/grammar/Python.g 2026-08-02 11:57:26 + +package org.python.antlr; + +import org.antlr.runtime.CommonToken; + +import org.python.antlr.ParseException; +import org.python.antlr.PythonTree; +import org.python.antlr.ast.alias; +import org.python.antlr.ast.arguments; +import org.python.antlr.ast.Assert; +import org.python.antlr.ast.Assign; +import org.python.antlr.ast.Attribute; +import org.python.antlr.ast.AugAssign; +import org.python.antlr.ast.BinOp; +import org.python.antlr.ast.BoolOp; +import org.python.antlr.ast.boolopType; +import org.python.antlr.ast.Break; +import org.python.antlr.ast.Call; +import org.python.antlr.ast.ClassDef; +import org.python.antlr.ast.cmpopType; +import org.python.antlr.ast.Compare; +import org.python.antlr.ast.comprehension; +import org.python.antlr.ast.Context; +import org.python.antlr.ast.Continue; +import org.python.antlr.ast.Delete; +import org.python.antlr.ast.Dict; +import org.python.antlr.ast.DictComp; +import org.python.antlr.ast.Ellipsis; +import org.python.antlr.ast.ErrorMod; +import org.python.antlr.ast.ExceptHandler; +import org.python.antlr.ast.Exec; +import org.python.antlr.ast.Expr; +import org.python.antlr.ast.Expression; +import org.python.antlr.ast.expr_contextType; +import org.python.antlr.ast.ExtSlice; +import org.python.antlr.ast.For; +import org.python.antlr.ast.GeneratorExp; +import org.python.antlr.ast.Global; +import org.python.antlr.ast.If; +import org.python.antlr.ast.IfExp; +import org.python.antlr.ast.Import; +import org.python.antlr.ast.ImportFrom; +import org.python.antlr.ast.Index; +import org.python.antlr.ast.Interactive; +import org.python.antlr.ast.keyword; +import org.python.antlr.ast.ListComp; +import org.python.antlr.ast.Lambda; +import org.python.antlr.ast.Module; +import org.python.antlr.ast.Name; +import org.python.antlr.ast.Num; +import org.python.antlr.ast.operatorType; +import org.python.antlr.ast.Pass; +import org.python.antlr.ast.Print; +import org.python.antlr.ast.Raise; +import org.python.antlr.ast.Repr; +import org.python.antlr.ast.Return; +import org.python.antlr.ast.Set; +import org.python.antlr.ast.SetComp; +import org.python.antlr.ast.Slice; +import org.python.antlr.ast.Str; +import org.python.antlr.ast.Subscript; +import org.python.antlr.ast.TryExcept; +import org.python.antlr.ast.TryFinally; +import org.python.antlr.ast.Tuple; +import org.python.antlr.ast.unaryopType; +import org.python.antlr.ast.UnaryOp; +import org.python.antlr.ast.While; +import org.python.antlr.ast.With; +import org.python.antlr.ast.Yield; +import org.python.antlr.base.excepthandler; +import org.python.antlr.base.expr; +import org.python.antlr.base.mod; +import org.python.antlr.base.slice; +import org.python.antlr.base.stmt; +import org.python.core.Py; +import org.python.core.PyObject; +import org.python.core.PyString; +import org.python.core.PyUnicode; + +import java.math.BigInteger; +import java.util.Collections; +import java.util.Iterator; +import java.util.ListIterator; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; + +import org.antlr.runtime.tree.*; + +/** Python 2.3.3 Grammar + * + * Terence Parr and Loring Craymer + * February 2004 + * + * Converted to ANTLR v3 November 2005 by Terence Parr. + * + * This grammar was derived automatically from the Python 2.3.3 + * parser grammar to get a syntactically correct ANTLR grammar + * for Python. Then Terence hand tweaked it to be semantically + * correct; i.e., removed lookahead issues etc... It is LL(1) + * except for the (sometimes optional) trailing commas and semi-colons. + * It needs two symbols of lookahead in this case. + * + * Starting with Loring's preliminary lexer for Python, I modified it + * to do my version of the whole nasty INDENT/DEDENT issue just so I + * could understand the problem better. This grammar requires + * PythonTokenStream.java to work. Also I used some rules from the + * semi-formal grammar on the web for Python (automatically + * translated to ANTLR format by an ANTLR grammar, naturally ). + * The lexical rules for python are particularly nasty and it took me + * a long time to get it 'right'; i.e., think about it in the proper + * way. Resist changing the lexer unless you've used ANTLR a lot. ;) + * + * I (Terence) tested this by running it on the jython-2.1/Lib + * directory of 40k lines of Python. + * + * REQUIRES ANTLR v3 + * + * + * Updated the original parser for Python 2.5 features. The parser has been + * altered to produce an AST - the AST work started from tne newcompiler + * grammar from Jim Baker. The current parsing and compiling strategy looks + * like this: + * + * Python source->Python.g->AST (org/python/parser/ast/*)->CodeCompiler(ASM)->.class + */ +public class PythonParser extends Parser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "INDENT", "DEDENT", "TRAILBACKSLASH", "NEWLINE", "LEADING_WS", "NAME", "DOT", "PRINT", "AND", "AS", "ASSERT", "BREAK", "CLASS", "CONTINUE", "DEF", "DELETE", "ELIF", "EXCEPT", "EXEC", "FINALLY", "FROM", "FOR", "GLOBAL", "IF", "IMPORT", "IN", "IS", "LAMBDA", "NOT", "OR", "ORELSE", "PASS", "RAISE", "RETURN", "TRY", "WHILE", "WITH", "YIELD", "AT", "LPAREN", "RPAREN", "COLON", "ASSIGN", "COMMA", "STAR", "DOUBLESTAR", "SEMI", "PLUSEQUAL", "MINUSEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", "DOUBLESTAREQUAL", "DOUBLESLASHEQUAL", "RIGHTSHIFT", "LESS", "GREATER", "EQUAL", "GREATEREQUAL", "LESSEQUAL", "ALT_NOTEQUAL", "NOTEQUAL", "VBAR", "CIRCUMFLEX", "AMPER", "LEFTSHIFT", "PLUS", "MINUS", "SLASH", "PERCENT", "DOUBLESLASH", "TILDE", "LBRACK", "RBRACK", "LCURLY", "RCURLY", "BACKQUOTE", "INT", "LONGINT", "FLOAT", "COMPLEX", "STRING", "DIGITS", "Exponent", "TRIAPOS", "TRIQUOTE", "ESC", "COMMENT", "CONTINUED_LINE", "WS" + }; + public static final int PRINT=11; + public static final int VBAREQUAL=57; + public static final int MINUS=76; + public static final int TRAILBACKSLASH=6; + public static final int SLASHEQUAL=54; + public static final int BREAK=15; + public static final int IF=27; + public static final int LESSEQUAL=68; + public static final int ELIF=20; + public static final int IN=29; + public static final int DOT=10; + public static final int LPAREN=43; + public static final int IS=30; + public static final int AS=13; + public static final int AT=42; + public static final int PASS=35; + public static final int LBRACK=81; + public static final int LEADING_WS=8; + public static final int LONGINT=87; + public static final int SEMI=50; + public static final int ASSIGN=46; + public static final int CIRCUMFLEXEQUAL=58; + public static final int DOUBLESTAREQUAL=61; + public static final int COMMENT=96; + public static final int INDENT=4; + public static final int IMPORT=28; + public static final int DELETE=19; + public static final int ESC=95; + public static final int ALT_NOTEQUAL=69; + public static final int RCURLY=84; + public static final int COMMA=47; + public static final int TRIQUOTE=94; + public static final int YIELD=41; + public static final int STAREQUAL=53; + public static final int GREATER=65; + public static final int LCURLY=83; + public static final int DOUBLESLASHEQUAL=62; + public static final int RAISE=36; + public static final int CONTINUE=17; + public static final int LEFTSHIFTEQUAL=59; + public static final int STAR=48; + public static final int PERCENT=78; + public static final int STRING=90; + public static final int BACKQUOTE=85; + public static final int CLASS=16; + public static final int FROM=24; + public static final int FINALLY=23; + public static final int RIGHTSHIFTEQUAL=60; + public static final int TRY=38; + public static final int NEWLINE=7; + public static final int FOR=25; + public static final int RPAREN=44; + public static final int EXCEPT=21; + public static final int RIGHTSHIFT=63; + public static final int NAME=9; + public static final int LAMBDA=31; + public static final int NOTEQUAL=70; + public static final int EXEC=22; + public static final int NOT=32; + public static final int RBRACK=82; + public static final int AND=12; + public static final int PERCENTEQUAL=55; + public static final int LESS=64; + public static final int LEFTSHIFT=74; + public static final int PLUS=75; + public static final int DOUBLESTAR=49; + public static final int FLOAT=88; + public static final int TRIAPOS=93; + public static final int Exponent=92; + public static final int DIGITS=91; + public static final int INT=86; + public static final int DOUBLESLASH=79; + public static final int RETURN=37; + public static final int GLOBAL=26; + public static final int CONTINUED_LINE=97; + public static final int WS=98; + public static final int EOF=-1; + public static final int CIRCUMFLEX=72; + public static final int COMPLEX=89; + public static final int OR=33; + public static final int DEF=18; + public static final int ASSERT=14; + public static final int AMPEREQUAL=56; + public static final int EQUAL=66; + public static final int SLASH=77; + public static final int AMPER=73; + public static final int COLON=45; + public static final int ORELSE=34; + public static final int WITH=40; + public static final int VBAR=71; + public static final int PLUSEQUAL=51; + public static final int MINUSEQUAL=52; + public static final int GREATEREQUAL=67; + public static final int WHILE=39; + public static final int TILDE=80; + public static final int DEDENT=5; + + // delegates + // delegators + + + public PythonParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public PythonParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + protected TreeAdaptor adaptor = new CommonTreeAdaptor(); + + public void setTreeAdaptor(TreeAdaptor adaptor) { + this.adaptor = adaptor; + } + public TreeAdaptor getTreeAdaptor() { + return adaptor; + } + + public String[] getTokenNames() { return PythonParser.tokenNames; } + public String getGrammarFileName() { return "/Users/orion.moore/apps/code/jython/grammar/Python.g"; } + + + private ErrorHandler errorHandler; + + private GrammarActions actions = new GrammarActions(); + + private String encoding; + + private boolean printFunction = false; + private boolean unicodeLiterals = false; + + public void setErrorHandler(ErrorHandler eh) { + this.errorHandler = eh; + actions.setErrorHandler(eh); + } + + protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) + throws RecognitionException { + + Object o = errorHandler.recoverFromMismatchedToken(this, input, ttype, follow); + if (o != null) { + return o; + } + return super.recoverFromMismatchedToken(input, ttype, follow); + } + + public PythonParser(TokenStream input, String encoding) { + this(input); + this.encoding = encoding; + } + + @Override + public void reportError(RecognitionException e) { + // Update syntax error count and output error. + super.reportError(e); + errorHandler.reportError(this, e); + } + + @Override + public void displayRecognitionError(String[] tokenNames, RecognitionException e) { + //Do nothing. We will handle error display elsewhere. + } + + + public static class single_input_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "single_input" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:295:1: single_input : ( ( NEWLINE )* EOF | simple_stmt ( NEWLINE )* EOF | compound_stmt ( NEWLINE )+ EOF ); + public final PythonParser.single_input_return single_input() throws RecognitionException { + PythonParser.single_input_return retval = new PythonParser.single_input_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NEWLINE1=null; + Token EOF2=null; + Token NEWLINE4=null; + Token EOF5=null; + Token NEWLINE7=null; + Token EOF8=null; + PythonParser.simple_stmt_return simple_stmt3 = null; + + PythonParser.compound_stmt_return compound_stmt6 = null; + + + PythonTree NEWLINE1_tree=null; + PythonTree EOF2_tree=null; + PythonTree NEWLINE4_tree=null; + PythonTree EOF5_tree=null; + PythonTree NEWLINE7_tree=null; + PythonTree EOF8_tree=null; + + + mod mtype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:302:5: ( ( NEWLINE )* EOF | simple_stmt ( NEWLINE )* EOF | compound_stmt ( NEWLINE )+ EOF ) + int alt4=3; + int LA4_0 = input.LA(1); + + if ( (LA4_0==EOF||LA4_0==NEWLINE) ) { + alt4=1; + } + else if ( (LA4_0==NAME||LA4_0==NOT||LA4_0==LPAREN||(LA4_0>=PLUS && LA4_0<=MINUS)||(LA4_0>=TILDE && LA4_0<=LBRACK)||LA4_0==LCURLY||LA4_0==BACKQUOTE) ) { + alt4=2; + } + else if ( (LA4_0==PRINT) && (((printFunction)||(!printFunction)))) { + alt4=2; + } + else if ( ((LA4_0>=ASSERT && LA4_0<=BREAK)||LA4_0==CONTINUE||LA4_0==DELETE||LA4_0==EXEC||LA4_0==FROM||LA4_0==GLOBAL||LA4_0==IMPORT||LA4_0==LAMBDA||(LA4_0>=PASS && LA4_0<=RETURN)||LA4_0==YIELD||(LA4_0>=INT && LA4_0<=STRING)) ) { + alt4=2; + } + else if ( (LA4_0==CLASS||LA4_0==DEF||LA4_0==FOR||LA4_0==IF||(LA4_0>=TRY && LA4_0<=WITH)||LA4_0==AT) ) { + alt4=3; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:302:7: ( NEWLINE )* EOF + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:302:7: ( NEWLINE )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==NEWLINE) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:302:7: NEWLINE + { + NEWLINE1=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_single_input118); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE1_tree = (PythonTree)adaptor.create(NEWLINE1); + adaptor.addChild(root_0, NEWLINE1_tree); + } + + } + break; + + default : + break loop1; + } + } while (true); + + EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_single_input121); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EOF2_tree = (PythonTree)adaptor.create(EOF2); + adaptor.addChild(root_0, EOF2_tree); + } + if ( state.backtracking==0 ) { + + mtype = new Interactive(((Token)retval.start), new ArrayList()); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:306:7: simple_stmt ( NEWLINE )* EOF + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_simple_stmt_in_single_input137); + simple_stmt3=simple_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_stmt3.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:306:19: ( NEWLINE )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==NEWLINE) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:306:19: NEWLINE + { + NEWLINE4=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_single_input139); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE4_tree = (PythonTree)adaptor.create(NEWLINE4); + adaptor.addChild(root_0, NEWLINE4_tree); + } + + } + break; + + default : + break loop2; + } + } while (true); + + EOF5=(Token)match(input,EOF,FOLLOW_EOF_in_single_input142); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EOF5_tree = (PythonTree)adaptor.create(EOF5); + adaptor.addChild(root_0, EOF5_tree); + } + if ( state.backtracking==0 ) { + + mtype = new Interactive(((Token)retval.start), actions.castStmts((simple_stmt3!=null?simple_stmt3.stypes:null))); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:310:7: compound_stmt ( NEWLINE )+ EOF + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_compound_stmt_in_single_input158); + compound_stmt6=compound_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, compound_stmt6.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:310:21: ( NEWLINE )+ + int cnt3=0; + loop3: + do { + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==NEWLINE) ) { + alt3=1; + } + + + switch (alt3) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:310:21: NEWLINE + { + NEWLINE7=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_single_input160); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE7_tree = (PythonTree)adaptor.create(NEWLINE7); + adaptor.addChild(root_0, NEWLINE7_tree); + } + + } + break; + + default : + if ( cnt3 >= 1 ) break loop3; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(3, input); + throw eee; + } + cnt3++; + } while (true); + + EOF8=(Token)match(input,EOF,FOLLOW_EOF_in_single_input163); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EOF8_tree = (PythonTree)adaptor.create(EOF8); + adaptor.addChild(root_0, EOF8_tree); + } + if ( state.backtracking==0 ) { + + mtype = new Interactive(((Token)retval.start), actions.castStmts((compound_stmt6!=null?((PythonTree)compound_stmt6.tree):null))); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = mtype; + + } + } + catch (RecognitionException re) { + + reportError(re); + errorHandler.recover(this, input,re); + PythonTree badNode = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + retval.tree = new ErrorMod(badNode); + + } + finally { + } + return retval; + } + // $ANTLR end "single_input" + + public static class file_input_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "file_input" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:324:1: file_input : ( NEWLINE | stmt )* EOF ; + public final PythonParser.file_input_return file_input() throws RecognitionException { + PythonParser.file_input_return retval = new PythonParser.file_input_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NEWLINE9=null; + Token EOF11=null; + PythonParser.stmt_return stmt10 = null; + + + PythonTree NEWLINE9_tree=null; + PythonTree EOF11_tree=null; + + + mod mtype = null; + List stypes = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:342:5: ( ( NEWLINE | stmt )* EOF ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:342:7: ( NEWLINE | stmt )* EOF + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:342:7: ( NEWLINE | stmt )* + loop5: + do { + int alt5=3; + int LA5_0 = input.LA(1); + + if ( (LA5_0==NEWLINE) ) { + alt5=1; + } + else if ( (LA5_0==NAME||LA5_0==NOT||LA5_0==LPAREN||(LA5_0>=PLUS && LA5_0<=MINUS)||(LA5_0>=TILDE && LA5_0<=LBRACK)||LA5_0==LCURLY||LA5_0==BACKQUOTE) ) { + alt5=2; + } + else if ( (LA5_0==PRINT) && (((printFunction)||(!printFunction)))) { + alt5=2; + } + else if ( ((LA5_0>=ASSERT && LA5_0<=DELETE)||LA5_0==EXEC||(LA5_0>=FROM && LA5_0<=IMPORT)||LA5_0==LAMBDA||(LA5_0>=PASS && LA5_0<=AT)||(LA5_0>=INT && LA5_0<=STRING)) ) { + alt5=2; + } + + + switch (alt5) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:342:8: NEWLINE + { + NEWLINE9=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_file_input215); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE9_tree = (PythonTree)adaptor.create(NEWLINE9); + adaptor.addChild(root_0, NEWLINE9_tree); + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:343:9: stmt + { + pushFollow(FOLLOW_stmt_in_file_input225); + stmt10=stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, stmt10.getTree()); + if ( state.backtracking==0 ) { + + if ((stmt10!=null?stmt10.stypes:null) != null) { + stypes.addAll((stmt10!=null?stmt10.stypes:null)); + } + + } + + } + break; + + default : + break loop5; + } + } while (true); + + EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_file_input244); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EOF11_tree = (PythonTree)adaptor.create(EOF11); + adaptor.addChild(root_0, EOF11_tree); + } + if ( state.backtracking==0 ) { + + mtype = new Module(((Token)retval.start), actions.castStmts(stypes)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (!stypes.isEmpty()) { + //The EOF token messes up the end offsets, so set them manually. + //XXX: this may no longer be true now that PythonTokenSource is + // adjusting EOF offsets -- but needs testing before I remove + // this. + PythonTree stop = (PythonTree)stypes.get(stypes.size() -1); + mtype.setCharStopIndex(stop.getCharStopIndex()); + mtype.setTokenStopIndex(stop.getTokenStopIndex()); + } + + retval.tree = mtype; + + } + } + catch (RecognitionException re) { + + reportError(re); + errorHandler.recover(this, input,re); + PythonTree badNode = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + retval.tree = new ErrorMod(badNode); + + } + finally { + } + return retval; + } + // $ANTLR end "file_input" + + public static class eval_input_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "eval_input" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:363:1: eval_input : ( LEADING_WS )? ( NEWLINE )* testlist[expr_contextType.Load] ( NEWLINE )* EOF ; + public final PythonParser.eval_input_return eval_input() throws RecognitionException { + PythonParser.eval_input_return retval = new PythonParser.eval_input_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LEADING_WS12=null; + Token NEWLINE13=null; + Token NEWLINE15=null; + Token EOF16=null; + PythonParser.testlist_return testlist14 = null; + + + PythonTree LEADING_WS12_tree=null; + PythonTree NEWLINE13_tree=null; + PythonTree NEWLINE15_tree=null; + PythonTree EOF16_tree=null; + + + mod mtype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:5: ( ( LEADING_WS )? ( NEWLINE )* testlist[expr_contextType.Load] ( NEWLINE )* EOF ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:7: ( LEADING_WS )? ( NEWLINE )* testlist[expr_contextType.Load] ( NEWLINE )* EOF + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:7: ( LEADING_WS )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==LEADING_WS) ) { + alt6=1; + } + switch (alt6) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:7: LEADING_WS + { + LEADING_WS12=(Token)match(input,LEADING_WS,FOLLOW_LEADING_WS_in_eval_input298); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LEADING_WS12_tree = (PythonTree)adaptor.create(LEADING_WS12); + adaptor.addChild(root_0, LEADING_WS12_tree); + } + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:19: ( NEWLINE )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==NEWLINE) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:20: NEWLINE + { + NEWLINE13=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_eval_input302); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE13_tree = (PythonTree)adaptor.create(NEWLINE13); + adaptor.addChild(root_0, NEWLINE13_tree); + } + + } + break; + + default : + break loop7; + } + } while (true); + + pushFollow(FOLLOW_testlist_in_eval_input306); + testlist14=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist14.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:62: ( NEWLINE )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==NEWLINE) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:370:63: NEWLINE + { + NEWLINE15=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_eval_input310); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE15_tree = (PythonTree)adaptor.create(NEWLINE15); + adaptor.addChild(root_0, NEWLINE15_tree); + } + + } + break; + + default : + break loop8; + } + } while (true); + + EOF16=(Token)match(input,EOF,FOLLOW_EOF_in_eval_input314); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EOF16_tree = (PythonTree)adaptor.create(EOF16); + adaptor.addChild(root_0, EOF16_tree); + } + if ( state.backtracking==0 ) { + + mtype = new Expression(((Token)retval.start), actions.castExpr((testlist14!=null?((PythonTree)testlist14.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = mtype; + + } + } + catch (RecognitionException re) { + + reportError(re); + errorHandler.recover(this, input,re); + PythonTree badNode = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + retval.tree = new ErrorMod(badNode); + + } + finally { + } + return retval; + } + // $ANTLR end "eval_input" + + public static class dotted_attr_return extends ParserRuleReturnScope { + public expr etype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "dotted_attr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:385:1: dotted_attr returns [expr etype] : n1= NAME ( ( DOT n2+= NAME )+ | ) ; + public final PythonParser.dotted_attr_return dotted_attr() throws RecognitionException { + PythonParser.dotted_attr_return retval = new PythonParser.dotted_attr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token n1=null; + Token DOT17=null; + Token n2=null; + List list_n2=null; + + PythonTree n1_tree=null; + PythonTree DOT17_tree=null; + PythonTree n2_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:387:5: (n1= NAME ( ( DOT n2+= NAME )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:387:7: n1= NAME ( ( DOT n2+= NAME )+ | ) + { + root_0 = (PythonTree)adaptor.nil(); + + n1=(Token)match(input,NAME,FOLLOW_NAME_in_dotted_attr366); if (state.failed) return retval; + if ( state.backtracking==0 ) { + n1_tree = (PythonTree)adaptor.create(n1); + adaptor.addChild(root_0, n1_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:388:7: ( ( DOT n2+= NAME )+ | ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==DOT) ) { + alt10=1; + } + else if ( (LA10_0==NEWLINE||LA10_0==LPAREN) ) { + alt10=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:388:9: ( DOT n2+= NAME )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:388:9: ( DOT n2+= NAME )+ + int cnt9=0; + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==DOT) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:388:10: DOT n2+= NAME + { + DOT17=(Token)match(input,DOT,FOLLOW_DOT_in_dotted_attr377); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOT17_tree = (PythonTree)adaptor.create(DOT17); + adaptor.addChild(root_0, DOT17_tree); + } + n2=(Token)match(input,NAME,FOLLOW_NAME_in_dotted_attr381); if (state.failed) return retval; + if ( state.backtracking==0 ) { + n2_tree = (PythonTree)adaptor.create(n2); + adaptor.addChild(root_0, n2_tree); + } + if (list_n2==null) list_n2=new ArrayList(); + list_n2.add(n2); + + + } + break; + + default : + if ( cnt9 >= 1 ) break loop9; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(9, input); + throw eee; + } + cnt9++; + } while (true); + + if ( state.backtracking==0 ) { + + retval.etype = actions.makeDottedAttr(n1, list_n2); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:393:9: + { + if ( state.backtracking==0 ) { + + retval.etype = actions.makeNameNode(n1); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "dotted_attr" + + public static class name_or_print_return extends ParserRuleReturnScope { + public Token tok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "name_or_print" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:401:1: name_or_print returns [Token tok] : ( NAME | {...}? => PRINT ); + public final PythonParser.name_or_print_return name_or_print() throws RecognitionException { + PythonParser.name_or_print_return retval = new PythonParser.name_or_print_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NAME18=null; + Token PRINT19=null; + + PythonTree NAME18_tree=null; + PythonTree PRINT19_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:403:5: ( NAME | {...}? => PRINT ) + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==NAME) ) { + alt11=1; + } + else if ( (LA11_0==PRINT) && ((printFunction))) { + alt11=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + + throw nvae; + } + switch (alt11) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:403:7: NAME + { + root_0 = (PythonTree)adaptor.nil(); + + NAME18=(Token)match(input,NAME,FOLLOW_NAME_in_name_or_print446); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NAME18_tree = (PythonTree)adaptor.create(NAME18); + adaptor.addChild(root_0, NAME18_tree); + } + if ( state.backtracking==0 ) { + + retval.tok = ((Token)retval.start); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:406:7: {...}? => PRINT + { + root_0 = (PythonTree)adaptor.nil(); + + if ( !((printFunction)) ) { + if (state.backtracking>0) {state.failed=true; return retval;} + throw new FailedPredicateException(input, "name_or_print", "printFunction"); + } + PRINT19=(Token)match(input,PRINT,FOLLOW_PRINT_in_name_or_print460); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PRINT19_tree = (PythonTree)adaptor.create(PRINT19); + adaptor.addChild(root_0, PRINT19_tree); + } + if ( state.backtracking==0 ) { + + retval.tok = ((Token)retval.start); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "name_or_print" + + public static class attr_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "attr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:415:1: attr : ( NAME | AND | AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | NOT | OR | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD ); + public final PythonParser.attr_return attr() throws RecognitionException { + PythonParser.attr_return retval = new PythonParser.attr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token set20=null; + + PythonTree set20_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:416:5: ( NAME | AND | AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | NOT | OR | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g: + { + root_0 = (PythonTree)adaptor.nil(); + + set20=(Token)input.LT(1); + if ( input.LA(1)==NAME||(input.LA(1)>=PRINT && input.LA(1)<=YIELD) ) { + input.consume(); + if ( state.backtracking==0 ) adaptor.addChild(root_0, (PythonTree)adaptor.create(set20)); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "attr" + + public static class decorator_return extends ParserRuleReturnScope { + public expr etype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "decorator" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:451:1: decorator returns [expr etype] : AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE ; + public final PythonParser.decorator_return decorator() throws RecognitionException { + PythonParser.decorator_return retval = new PythonParser.decorator_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token AT21=null; + Token LPAREN23=null; + Token RPAREN25=null; + Token NEWLINE26=null; + PythonParser.dotted_attr_return dotted_attr22 = null; + + PythonParser.arglist_return arglist24 = null; + + + PythonTree AT21_tree=null; + PythonTree LPAREN23_tree=null; + PythonTree RPAREN25_tree=null; + PythonTree NEWLINE26_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:456:5: ( AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:456:7: AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE + { + root_0 = (PythonTree)adaptor.nil(); + + AT21=(Token)match(input,AT,FOLLOW_AT_in_decorator762); if (state.failed) return retval; + if ( state.backtracking==0 ) { + AT21_tree = (PythonTree)adaptor.create(AT21); + adaptor.addChild(root_0, AT21_tree); + } + pushFollow(FOLLOW_dotted_attr_in_decorator764); + dotted_attr22=dotted_attr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, dotted_attr22.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:457:5: ( LPAREN ( arglist | ) RPAREN | ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==LPAREN) ) { + alt13=1; + } + else if ( (LA13_0==NEWLINE) ) { + alt13=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:457:7: LPAREN ( arglist | ) RPAREN + { + LPAREN23=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_decorator772); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN23_tree = (PythonTree)adaptor.create(LPAREN23); + adaptor.addChild(root_0, LPAREN23_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:458:7: ( arglist | ) + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==NAME||LA12_0==NOT||LA12_0==LPAREN||(LA12_0>=PLUS && LA12_0<=MINUS)||(LA12_0>=TILDE && LA12_0<=LBRACK)||LA12_0==LCURLY||LA12_0==BACKQUOTE) ) { + alt12=1; + } + else if ( (LA12_0==PRINT) && ((printFunction))) { + alt12=1; + } + else if ( (LA12_0==LAMBDA||(LA12_0>=STAR && LA12_0<=DOUBLESTAR)||(LA12_0>=INT && LA12_0<=STRING)) ) { + alt12=1; + } + else if ( (LA12_0==RPAREN) ) { + alt12=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + switch (alt12) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:458:9: arglist + { + pushFollow(FOLLOW_arglist_in_decorator782); + arglist24=arglist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, arglist24.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = actions.makeCall(LPAREN23, (dotted_attr22!=null?dotted_attr22.etype:null), (arglist24!=null?arglist24.args:null), (arglist24!=null?arglist24.keywords:null), + (arglist24!=null?arglist24.starargs:null), (arglist24!=null?arglist24.kwargs:null)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:464:9: + { + if ( state.backtracking==0 ) { + + retval.etype = actions.makeCall(LPAREN23, (dotted_attr22!=null?dotted_attr22.etype:null)); + + } + + } + break; + + } + + RPAREN25=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_decorator826); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN25_tree = (PythonTree)adaptor.create(RPAREN25); + adaptor.addChild(root_0, RPAREN25_tree); + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:470:7: + { + if ( state.backtracking==0 ) { + + retval.etype = (dotted_attr22!=null?dotted_attr22.etype:null); + + } + + } + break; + + } + + NEWLINE26=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_decorator848); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE26_tree = (PythonTree)adaptor.create(NEWLINE26); + adaptor.addChild(root_0, NEWLINE26_tree); + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "decorator" + + public static class decorators_return extends ParserRuleReturnScope { + public List etypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "decorators" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:477:1: decorators returns [List etypes] : (d+= decorator )+ ; + public final PythonParser.decorators_return decorators() throws RecognitionException { + PythonParser.decorators_return retval = new PythonParser.decorators_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + List list_d=null; + PythonParser.decorator_return d = null; + d = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:479:5: ( (d+= decorator )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:479:7: (d+= decorator )+ + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:479:8: (d+= decorator )+ + int cnt14=0; + loop14: + do { + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==AT) ) { + alt14=1; + } + + + switch (alt14) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:479:8: d+= decorator + { + pushFollow(FOLLOW_decorator_in_decorators876); + d=decorator(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree()); + if (list_d==null) list_d=new ArrayList(); + list_d.add(d.getTree()); + + + } + break; + + default : + if ( cnt14 >= 1 ) break loop14; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(14, input); + throw eee; + } + cnt14++; + } while (true); + + if ( state.backtracking==0 ) { + + retval.etypes = list_d; + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "decorators" + + public static class funcdef_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "funcdef" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:486:1: funcdef : ( decorators )? DEF name_or_print parameters COLON suite[false] ; + public final PythonParser.funcdef_return funcdef() throws RecognitionException { + PythonParser.funcdef_return retval = new PythonParser.funcdef_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token DEF28=null; + Token COLON31=null; + PythonParser.decorators_return decorators27 = null; + + PythonParser.name_or_print_return name_or_print29 = null; + + PythonParser.parameters_return parameters30 = null; + + PythonParser.suite_return suite32 = null; + + + PythonTree DEF28_tree=null; + PythonTree COLON31_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:494:5: ( ( decorators )? DEF name_or_print parameters COLON suite[false] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:494:7: ( decorators )? DEF name_or_print parameters COLON suite[false] + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:494:7: ( decorators )? + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==AT) ) { + alt15=1; + } + switch (alt15) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:494:7: decorators + { + pushFollow(FOLLOW_decorators_in_funcdef914); + decorators27=decorators(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, decorators27.getTree()); + + } + break; + + } + + DEF28=(Token)match(input,DEF,FOLLOW_DEF_in_funcdef917); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DEF28_tree = (PythonTree)adaptor.create(DEF28); + adaptor.addChild(root_0, DEF28_tree); + } + pushFollow(FOLLOW_name_or_print_in_funcdef919); + name_or_print29=name_or_print(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, name_or_print29.getTree()); + pushFollow(FOLLOW_parameters_in_funcdef921); + parameters30=parameters(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, parameters30.getTree()); + COLON31=(Token)match(input,COLON,FOLLOW_COLON_in_funcdef923); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON31_tree = (PythonTree)adaptor.create(COLON31); + adaptor.addChild(root_0, COLON31_tree); + } + pushFollow(FOLLOW_suite_in_funcdef925); + suite32=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, suite32.getTree()); + if ( state.backtracking==0 ) { + + Token t = DEF28; + if ((decorators27!=null?((Token)decorators27.start):null) != null) { + t = (decorators27!=null?((Token)decorators27.start):null); + } + stype = actions.makeFuncdef(t, (name_or_print29!=null?((Token)name_or_print29.start):null), (parameters30!=null?parameters30.args:null), (suite32!=null?suite32.stypes:null), (decorators27!=null?decorators27.etypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "funcdef" + + public static class parameters_return extends ParserRuleReturnScope { + public arguments args; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "parameters" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:505:1: parameters returns [arguments args] : LPAREN ( varargslist | ) RPAREN ; + public final PythonParser.parameters_return parameters() throws RecognitionException { + PythonParser.parameters_return retval = new PythonParser.parameters_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LPAREN33=null; + Token RPAREN35=null; + PythonParser.varargslist_return varargslist34 = null; + + + PythonTree LPAREN33_tree=null; + PythonTree RPAREN35_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:507:5: ( LPAREN ( varargslist | ) RPAREN ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:507:7: LPAREN ( varargslist | ) RPAREN + { + root_0 = (PythonTree)adaptor.nil(); + + LPAREN33=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_parameters958); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN33_tree = (PythonTree)adaptor.create(LPAREN33); + adaptor.addChild(root_0, LPAREN33_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:508:7: ( varargslist | ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==NAME||LA16_0==LPAREN||(LA16_0>=STAR && LA16_0<=DOUBLESTAR)) ) { + alt16=1; + } + else if ( (LA16_0==RPAREN) ) { + alt16=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:508:8: varargslist + { + pushFollow(FOLLOW_varargslist_in_parameters967); + varargslist34=varargslist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, varargslist34.getTree()); + if ( state.backtracking==0 ) { + + retval.args = (varargslist34!=null?varargslist34.args:null); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:513:9: + { + if ( state.backtracking==0 ) { + + retval.args = new arguments(((Token)retval.start), new ArrayList(), (Name)null, null, new ArrayList()); + + } + + } + break; + + } + + RPAREN35=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_parameters1011); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN35_tree = (PythonTree)adaptor.create(RPAREN35); + adaptor.addChild(root_0, RPAREN35_tree); + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "parameters" + + public static class defparameter_return extends ParserRuleReturnScope { + public expr etype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "defparameter" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:521:1: defparameter[List defaults] returns [expr etype] : fpdef[expr_contextType.Param] ( ASSIGN test[expr_contextType.Load] )? ; + public final PythonParser.defparameter_return defparameter(List defaults) throws RecognitionException { + PythonParser.defparameter_return retval = new PythonParser.defparameter_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token ASSIGN37=null; + PythonParser.fpdef_return fpdef36 = null; + + PythonParser.test_return test38 = null; + + + PythonTree ASSIGN37_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:526:5: ( fpdef[expr_contextType.Param] ( ASSIGN test[expr_contextType.Load] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:526:7: fpdef[expr_contextType.Param] ( ASSIGN test[expr_contextType.Load] )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_fpdef_in_defparameter1044); + fpdef36=fpdef(expr_contextType.Param); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, fpdef36.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:526:37: ( ASSIGN test[expr_contextType.Load] )? + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==ASSIGN) ) { + alt17=1; + } + switch (alt17) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:526:38: ASSIGN test[expr_contextType.Load] + { + ASSIGN37=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_defparameter1048); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ASSIGN37_tree = (PythonTree)adaptor.create(ASSIGN37); + adaptor.addChild(root_0, ASSIGN37_tree); + } + pushFollow(FOLLOW_test_in_defparameter1050); + test38=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test38.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.etype = actions.castExpr((fpdef36!=null?((PythonTree)fpdef36.tree):null)); + if (ASSIGN37 != null) { + defaults.add((test38!=null?((PythonTree)test38.tree):null)); + } else if (!defaults.isEmpty()) { + throw new ParseException("non-default argument follows default argument", (fpdef36!=null?((PythonTree)fpdef36.tree):null)); + } + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "defparameter" + + public static class varargslist_return extends ParserRuleReturnScope { + public arguments args; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "varargslist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:540:1: varargslist returns [arguments args] : (d+= defparameter[defaults] ( options {greedy=true; } : COMMA d+= defparameter[defaults] )* ( COMMA ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? )? | STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME ); + public final PythonParser.varargslist_return varargslist() throws RecognitionException { + PythonParser.varargslist_return retval = new PythonParser.varargslist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token starargs=null; + Token kwargs=null; + Token COMMA39=null; + Token COMMA40=null; + Token STAR41=null; + Token COMMA42=null; + Token DOUBLESTAR43=null; + Token DOUBLESTAR44=null; + Token STAR45=null; + Token COMMA46=null; + Token DOUBLESTAR47=null; + Token DOUBLESTAR48=null; + List list_d=null; + PythonParser.defparameter_return d = null; + d = null; + PythonTree starargs_tree=null; + PythonTree kwargs_tree=null; + PythonTree COMMA39_tree=null; + PythonTree COMMA40_tree=null; + PythonTree STAR41_tree=null; + PythonTree COMMA42_tree=null; + PythonTree DOUBLESTAR43_tree=null; + PythonTree DOUBLESTAR44_tree=null; + PythonTree STAR45_tree=null; + PythonTree COMMA46_tree=null; + PythonTree DOUBLESTAR47_tree=null; + PythonTree DOUBLESTAR48_tree=null; + + + List defaults = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:545:5: (d+= defparameter[defaults] ( options {greedy=true; } : COMMA d+= defparameter[defaults] )* ( COMMA ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? )? | STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME ) + int alt23=3; + switch ( input.LA(1) ) { + case NAME: + case LPAREN: + { + alt23=1; + } + break; + case STAR: + { + alt23=2; + } + break; + case DOUBLESTAR: + { + alt23=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 23, 0, input); + + throw nvae; + } + + switch (alt23) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:545:7: d+= defparameter[defaults] ( options {greedy=true; } : COMMA d+= defparameter[defaults] )* ( COMMA ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_defparameter_in_varargslist1096); + d=defparameter(defaults); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree()); + if (list_d==null) list_d=new ArrayList(); + list_d.add(d.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:545:33: ( options {greedy=true; } : COMMA d+= defparameter[defaults] )* + loop18: + do { + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==COMMA) ) { + int LA18_1 = input.LA(2); + + if ( (LA18_1==NAME||LA18_1==LPAREN) ) { + alt18=1; + } + + + } + + + switch (alt18) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:545:57: COMMA d+= defparameter[defaults] + { + COMMA39=(Token)match(input,COMMA,FOLLOW_COMMA_in_varargslist1107); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA39_tree = (PythonTree)adaptor.create(COMMA39); + adaptor.addChild(root_0, COMMA39_tree); + } + pushFollow(FOLLOW_defparameter_in_varargslist1111); + d=defparameter(defaults); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree()); + if (list_d==null) list_d=new ArrayList(); + list_d.add(d.getTree()); + + + } + break; + + default : + break loop18; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:546:7: ( COMMA ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? )? + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==COMMA) ) { + alt21=1; + } + switch (alt21) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:546:8: COMMA ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? + { + COMMA40=(Token)match(input,COMMA,FOLLOW_COMMA_in_varargslist1123); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA40_tree = (PythonTree)adaptor.create(COMMA40); + adaptor.addChild(root_0, COMMA40_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:547:11: ( STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? | DOUBLESTAR kwargs= NAME )? + int alt20=3; + int LA20_0 = input.LA(1); + + if ( (LA20_0==STAR) ) { + alt20=1; + } + else if ( (LA20_0==DOUBLESTAR) ) { + alt20=2; + } + switch (alt20) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:547:12: STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? + { + STAR41=(Token)match(input,STAR,FOLLOW_STAR_in_varargslist1136); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR41_tree = (PythonTree)adaptor.create(STAR41); + adaptor.addChild(root_0, STAR41_tree); + } + starargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1140); if (state.failed) return retval; + if ( state.backtracking==0 ) { + starargs_tree = (PythonTree)adaptor.create(starargs); + adaptor.addChild(root_0, starargs_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:547:31: ( COMMA DOUBLESTAR kwargs= NAME )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==COMMA) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:547:32: COMMA DOUBLESTAR kwargs= NAME + { + COMMA42=(Token)match(input,COMMA,FOLLOW_COMMA_in_varargslist1143); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA42_tree = (PythonTree)adaptor.create(COMMA42); + adaptor.addChild(root_0, COMMA42_tree); + } + DOUBLESTAR43=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist1145); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR43_tree = (PythonTree)adaptor.create(DOUBLESTAR43); + adaptor.addChild(root_0, DOUBLESTAR43_tree); + } + kwargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1149); if (state.failed) return retval; + if ( state.backtracking==0 ) { + kwargs_tree = (PythonTree)adaptor.create(kwargs); + adaptor.addChild(root_0, kwargs_tree); + } + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:548:13: DOUBLESTAR kwargs= NAME + { + DOUBLESTAR44=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist1165); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR44_tree = (PythonTree)adaptor.create(DOUBLESTAR44); + adaptor.addChild(root_0, DOUBLESTAR44_tree); + } + kwargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1169); if (state.failed) return retval; + if ( state.backtracking==0 ) { + kwargs_tree = (PythonTree)adaptor.create(kwargs); + adaptor.addChild(root_0, kwargs_tree); + } + + } + break; + + } + + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.args = actions.makeArgumentsType(((Token)retval.start), list_d, starargs, kwargs, defaults); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:554:7: STAR starargs= NAME ( COMMA DOUBLESTAR kwargs= NAME )? + { + root_0 = (PythonTree)adaptor.nil(); + + STAR45=(Token)match(input,STAR,FOLLOW_STAR_in_varargslist1207); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR45_tree = (PythonTree)adaptor.create(STAR45); + adaptor.addChild(root_0, STAR45_tree); + } + starargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1211); if (state.failed) return retval; + if ( state.backtracking==0 ) { + starargs_tree = (PythonTree)adaptor.create(starargs); + adaptor.addChild(root_0, starargs_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:554:26: ( COMMA DOUBLESTAR kwargs= NAME )? + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==COMMA) ) { + alt22=1; + } + switch (alt22) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:554:27: COMMA DOUBLESTAR kwargs= NAME + { + COMMA46=(Token)match(input,COMMA,FOLLOW_COMMA_in_varargslist1214); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA46_tree = (PythonTree)adaptor.create(COMMA46); + adaptor.addChild(root_0, COMMA46_tree); + } + DOUBLESTAR47=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist1216); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR47_tree = (PythonTree)adaptor.create(DOUBLESTAR47); + adaptor.addChild(root_0, DOUBLESTAR47_tree); + } + kwargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1220); if (state.failed) return retval; + if ( state.backtracking==0 ) { + kwargs_tree = (PythonTree)adaptor.create(kwargs); + adaptor.addChild(root_0, kwargs_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.args = actions.makeArgumentsType(((Token)retval.start), list_d, starargs, kwargs, defaults); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:558:7: DOUBLESTAR kwargs= NAME + { + root_0 = (PythonTree)adaptor.nil(); + + DOUBLESTAR48=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist1238); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR48_tree = (PythonTree)adaptor.create(DOUBLESTAR48); + adaptor.addChild(root_0, DOUBLESTAR48_tree); + } + kwargs=(Token)match(input,NAME,FOLLOW_NAME_in_varargslist1242); if (state.failed) return retval; + if ( state.backtracking==0 ) { + kwargs_tree = (PythonTree)adaptor.create(kwargs); + adaptor.addChild(root_0, kwargs_tree); + } + if ( state.backtracking==0 ) { + + retval.args = actions.makeArgumentsType(((Token)retval.start), list_d, null, kwargs, defaults); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "varargslist" + + public static class fpdef_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "fpdef" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:565:1: fpdef[expr_contextType ctype] : ( NAME | ( LPAREN fpdef[null] COMMA )=> LPAREN fplist RPAREN | LPAREN fplist RPAREN ); + public final PythonParser.fpdef_return fpdef(expr_contextType ctype) throws RecognitionException { + PythonParser.fpdef_return retval = new PythonParser.fpdef_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NAME49=null; + Token LPAREN50=null; + Token RPAREN52=null; + Token LPAREN53=null; + Token RPAREN55=null; + PythonParser.fplist_return fplist51 = null; + + PythonParser.fplist_return fplist54 = null; + + + PythonTree NAME49_tree=null; + PythonTree LPAREN50_tree=null; + PythonTree RPAREN52_tree=null; + PythonTree LPAREN53_tree=null; + PythonTree RPAREN55_tree=null; + + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:575:5: ( NAME | ( LPAREN fpdef[null] COMMA )=> LPAREN fplist RPAREN | LPAREN fplist RPAREN ) + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0==NAME) ) { + alt24=1; + } + else if ( (LA24_0==LPAREN) ) { + int LA24_2 = input.LA(2); + + if ( (synpred1_Python()) ) { + alt24=2; + } + else if ( (true) ) { + alt24=3; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 24, 2, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + + throw nvae; + } + switch (alt24) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:575:7: NAME + { + root_0 = (PythonTree)adaptor.nil(); + + NAME49=(Token)match(input,NAME,FOLLOW_NAME_in_fpdef1279); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NAME49_tree = (PythonTree)adaptor.create(NAME49); + adaptor.addChild(root_0, NAME49_tree); + } + if ( state.backtracking==0 ) { + + etype = new Name(NAME49, (NAME49!=null?NAME49.getText():null), ctype); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:579:7: ( LPAREN fpdef[null] COMMA )=> LPAREN fplist RPAREN + { + root_0 = (PythonTree)adaptor.nil(); + + LPAREN50=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_fpdef1306); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN50_tree = (PythonTree)adaptor.create(LPAREN50); + adaptor.addChild(root_0, LPAREN50_tree); + } + pushFollow(FOLLOW_fplist_in_fpdef1308); + fplist51=fplist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, fplist51.getTree()); + RPAREN52=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_fpdef1310); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN52_tree = (PythonTree)adaptor.create(RPAREN52); + adaptor.addChild(root_0, RPAREN52_tree); + } + if ( state.backtracking==0 ) { + + etype = new Tuple((fplist51!=null?((Token)fplist51.start):null), actions.castExprs((fplist51!=null?fplist51.etypes:null)), expr_contextType.Store); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:583:7: LPAREN fplist RPAREN + { + root_0 = (PythonTree)adaptor.nil(); + + LPAREN53=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_fpdef1326); if (state.failed) return retval; + pushFollow(FOLLOW_fplist_in_fpdef1329); + fplist54=fplist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, fplist54.getTree()); + RPAREN55=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_fpdef1331); if (state.failed) return retval; + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + actions.checkAssign(actions.castExpr(((PythonTree)retval.tree))); + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "fpdef" + + public static class fplist_return extends ParserRuleReturnScope { + public List etypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "fplist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:587:1: fplist returns [List etypes] : f+= fpdef[expr_contextType.Store] ( options {greedy=true; } : COMMA f+= fpdef[expr_contextType.Store] )* ( COMMA )? ; + public final PythonParser.fplist_return fplist() throws RecognitionException { + PythonParser.fplist_return retval = new PythonParser.fplist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA56=null; + Token COMMA57=null; + List list_f=null; + PythonParser.fpdef_return f = null; + f = null; + PythonTree COMMA56_tree=null; + PythonTree COMMA57_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:589:5: (f+= fpdef[expr_contextType.Store] ( options {greedy=true; } : COMMA f+= fpdef[expr_contextType.Store] )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:589:7: f+= fpdef[expr_contextType.Store] ( options {greedy=true; } : COMMA f+= fpdef[expr_contextType.Store] )* ( COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_fpdef_in_fplist1360); + f=fpdef(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, f.getTree()); + if (list_f==null) list_f=new ArrayList(); + list_f.add(f.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:590:7: ( options {greedy=true; } : COMMA f+= fpdef[expr_contextType.Store] )* + loop25: + do { + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==COMMA) ) { + int LA25_1 = input.LA(2); + + if ( (LA25_1==NAME||LA25_1==LPAREN) ) { + alt25=1; + } + + + } + + + switch (alt25) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:590:31: COMMA f+= fpdef[expr_contextType.Store] + { + COMMA56=(Token)match(input,COMMA,FOLLOW_COMMA_in_fplist1377); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA56_tree = (PythonTree)adaptor.create(COMMA56); + adaptor.addChild(root_0, COMMA56_tree); + } + pushFollow(FOLLOW_fpdef_in_fplist1381); + f=fpdef(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, f.getTree()); + if (list_f==null) list_f=new ArrayList(); + list_f.add(f.getTree()); + + + } + break; + + default : + break loop25; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:590:72: ( COMMA )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==COMMA) ) { + alt26=1; + } + switch (alt26) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:590:73: COMMA + { + COMMA57=(Token)match(input,COMMA,FOLLOW_COMMA_in_fplist1387); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA57_tree = (PythonTree)adaptor.create(COMMA57); + adaptor.addChild(root_0, COMMA57_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.etypes = list_f; + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "fplist" + + public static class stmt_return extends ParserRuleReturnScope { + public List stypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:597:1: stmt returns [List stypes] : ( simple_stmt | compound_stmt ); + public final PythonParser.stmt_return stmt() throws RecognitionException { + PythonParser.stmt_return retval = new PythonParser.stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.simple_stmt_return simple_stmt58 = null; + + PythonParser.compound_stmt_return compound_stmt59 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:599:5: ( simple_stmt | compound_stmt ) + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==NAME||LA27_0==NOT||LA27_0==LPAREN||(LA27_0>=PLUS && LA27_0<=MINUS)||(LA27_0>=TILDE && LA27_0<=LBRACK)||LA27_0==LCURLY||LA27_0==BACKQUOTE) ) { + alt27=1; + } + else if ( (LA27_0==PRINT) && (((printFunction)||(!printFunction)))) { + alt27=1; + } + else if ( ((LA27_0>=ASSERT && LA27_0<=BREAK)||LA27_0==CONTINUE||LA27_0==DELETE||LA27_0==EXEC||LA27_0==FROM||LA27_0==GLOBAL||LA27_0==IMPORT||LA27_0==LAMBDA||(LA27_0>=PASS && LA27_0<=RETURN)||LA27_0==YIELD||(LA27_0>=INT && LA27_0<=STRING)) ) { + alt27=1; + } + else if ( (LA27_0==CLASS||LA27_0==DEF||LA27_0==FOR||LA27_0==IF||(LA27_0>=TRY && LA27_0<=WITH)||LA27_0==AT) ) { + alt27=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 27, 0, input); + + throw nvae; + } + switch (alt27) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:599:7: simple_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_simple_stmt_in_stmt1423); + simple_stmt58=simple_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_stmt58.getTree()); + if ( state.backtracking==0 ) { + + retval.stypes = (simple_stmt58!=null?simple_stmt58.stypes:null); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:603:7: compound_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_compound_stmt_in_stmt1439); + compound_stmt59=compound_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, compound_stmt59.getTree()); + if ( state.backtracking==0 ) { + + retval.stypes = new ArrayList(); + retval.stypes.add((compound_stmt59!=null?((PythonTree)compound_stmt59.tree):null)); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "stmt" + + public static class simple_stmt_return extends ParserRuleReturnScope { + public List stypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "simple_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:611:1: simple_stmt returns [List stypes] : s+= small_stmt ( options {greedy=true; } : SEMI s+= small_stmt )* ( SEMI )? NEWLINE ; + public final PythonParser.simple_stmt_return simple_stmt() throws RecognitionException { + PythonParser.simple_stmt_return retval = new PythonParser.simple_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token SEMI60=null; + Token SEMI61=null; + Token NEWLINE62=null; + List list_s=null; + PythonParser.small_stmt_return s = null; + s = null; + PythonTree SEMI60_tree=null; + PythonTree SEMI61_tree=null; + PythonTree NEWLINE62_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:5: (s+= small_stmt ( options {greedy=true; } : SEMI s+= small_stmt )* ( SEMI )? NEWLINE ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:7: s+= small_stmt ( options {greedy=true; } : SEMI s+= small_stmt )* ( SEMI )? NEWLINE + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_small_stmt_in_simple_stmt1475); + s=small_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree()); + if (list_s==null) list_s=new ArrayList(); + list_s.add(s.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:21: ( options {greedy=true; } : SEMI s+= small_stmt )* + loop28: + do { + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==SEMI) ) { + int LA28_1 = input.LA(2); + + if ( (LA28_1==NAME||LA28_1==PRINT||(LA28_1>=ASSERT && LA28_1<=BREAK)||LA28_1==CONTINUE||LA28_1==DELETE||LA28_1==EXEC||LA28_1==FROM||LA28_1==GLOBAL||LA28_1==IMPORT||(LA28_1>=LAMBDA && LA28_1<=NOT)||(LA28_1>=PASS && LA28_1<=RETURN)||LA28_1==YIELD||LA28_1==LPAREN||(LA28_1>=PLUS && LA28_1<=MINUS)||(LA28_1>=TILDE && LA28_1<=LBRACK)||LA28_1==LCURLY||(LA28_1>=BACKQUOTE && LA28_1<=STRING)) ) { + alt28=1; + } + + + } + + + switch (alt28) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:45: SEMI s+= small_stmt + { + SEMI60=(Token)match(input,SEMI,FOLLOW_SEMI_in_simple_stmt1485); if (state.failed) return retval; + if ( state.backtracking==0 ) { + SEMI60_tree = (PythonTree)adaptor.create(SEMI60); + adaptor.addChild(root_0, SEMI60_tree); + } + pushFollow(FOLLOW_small_stmt_in_simple_stmt1489); + s=small_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree()); + if (list_s==null) list_s=new ArrayList(); + list_s.add(s.getTree()); + + + } + break; + + default : + break loop28; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:66: ( SEMI )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==SEMI) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:613:67: SEMI + { + SEMI61=(Token)match(input,SEMI,FOLLOW_SEMI_in_simple_stmt1494); if (state.failed) return retval; + if ( state.backtracking==0 ) { + SEMI61_tree = (PythonTree)adaptor.create(SEMI61); + adaptor.addChild(root_0, SEMI61_tree); + } + + } + break; + + } + + NEWLINE62=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_simple_stmt1498); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE62_tree = (PythonTree)adaptor.create(NEWLINE62); + adaptor.addChild(root_0, NEWLINE62_tree); + } + if ( state.backtracking==0 ) { + + retval.stypes = list_s; + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "simple_stmt" + + public static class small_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "small_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:621:1: small_stmt : ( expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt | {...}? => print_stmt ); + public final PythonParser.small_stmt_return small_stmt() throws RecognitionException { + PythonParser.small_stmt_return retval = new PythonParser.small_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.expr_stmt_return expr_stmt63 = null; + + PythonParser.del_stmt_return del_stmt64 = null; + + PythonParser.pass_stmt_return pass_stmt65 = null; + + PythonParser.flow_stmt_return flow_stmt66 = null; + + PythonParser.import_stmt_return import_stmt67 = null; + + PythonParser.global_stmt_return global_stmt68 = null; + + PythonParser.exec_stmt_return exec_stmt69 = null; + + PythonParser.assert_stmt_return assert_stmt70 = null; + + PythonParser.print_stmt_return print_stmt71 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:621:12: ( expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt | {...}? => print_stmt ) + int alt30=9; + alt30 = dfa30.predict(input); + switch (alt30) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:621:14: expr_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_expr_stmt_in_small_stmt1521); + expr_stmt63=expr_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, expr_stmt63.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:622:14: del_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_del_stmt_in_small_stmt1536); + del_stmt64=del_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, del_stmt64.getTree()); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:623:14: pass_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_pass_stmt_in_small_stmt1551); + pass_stmt65=pass_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, pass_stmt65.getTree()); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:624:14: flow_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_flow_stmt_in_small_stmt1566); + flow_stmt66=flow_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, flow_stmt66.getTree()); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:625:14: import_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_import_stmt_in_small_stmt1581); + import_stmt67=import_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, import_stmt67.getTree()); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:626:14: global_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_global_stmt_in_small_stmt1596); + global_stmt68=global_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, global_stmt68.getTree()); + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:627:14: exec_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_exec_stmt_in_small_stmt1611); + exec_stmt69=exec_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, exec_stmt69.getTree()); + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:628:14: assert_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_assert_stmt_in_small_stmt1626); + assert_stmt70=assert_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, assert_stmt70.getTree()); + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:629:14: {...}? => print_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + if ( !((!printFunction)) ) { + if (state.backtracking>0) {state.failed=true; return retval;} + throw new FailedPredicateException(input, "small_stmt", "!printFunction"); + } + pushFollow(FOLLOW_print_stmt_in_small_stmt1645); + print_stmt71=print_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, print_stmt71.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "small_stmt" + + public static class expr_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "expr_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:634:1: expr_stmt : ( ( testlist[null] augassign )=>lhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) | ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) | lhs= testlist[expr_contextType.Load] ) ; + public final PythonParser.expr_stmt_return expr_stmt() throws RecognitionException { + PythonParser.expr_stmt_return retval = new PythonParser.expr_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token at=null; + Token ay=null; + List list_t=null; + List list_y2=null; + PythonParser.testlist_return lhs = null; + + PythonParser.augassign_return aay = null; + + PythonParser.yield_expr_return y1 = null; + + PythonParser.augassign_return aat = null; + + PythonParser.testlist_return rhs = null; + + PythonParser.testlist_return t = null; + t = null; + PythonParser.yield_expr_return y2 = null; + y2 = null; + PythonTree at_tree=null; + PythonTree ay_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:5: ( ( ( testlist[null] augassign )=>lhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) | ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) | lhs= testlist[expr_contextType.Load] ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:7: ( ( testlist[null] augassign )=>lhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) | ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) | lhs= testlist[expr_contextType.Load] ) + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:7: ( ( testlist[null] augassign )=>lhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) | ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) | lhs= testlist[expr_contextType.Load] ) + int alt35=3; + alt35 = dfa35.predict(input); + switch (alt35) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:8: ( testlist[null] augassign )=>lhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) + { + pushFollow(FOLLOW_testlist_in_expr_stmt1693); + lhs=testlist(expr_contextType.AugStore); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, lhs.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:644:9: ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) + int alt31=2; + alt31 = dfa31.predict(input); + switch (alt31) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:644:11: (aay= augassign y1= yield_expr ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:644:11: (aay= augassign y1= yield_expr ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:644:12: aay= augassign y1= yield_expr + { + pushFollow(FOLLOW_augassign_in_expr_stmt1709); + aay=augassign(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, aay.getTree()); + pushFollow(FOLLOW_yield_expr_in_expr_stmt1713); + y1=yield_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, y1.getTree()); + if ( state.backtracking==0 ) { + + actions.checkAugAssign(actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null))); + stype = new AugAssign((lhs!=null?((PythonTree)lhs.tree):null), actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null)), (aay!=null?aay.op:null), actions.castExpr((y1!=null?y1.etype:null))); + + } + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:650:11: (aat= augassign rhs= testlist[expr_contextType.Load] ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:650:11: (aat= augassign rhs= testlist[expr_contextType.Load] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:650:12: aat= augassign rhs= testlist[expr_contextType.Load] + { + pushFollow(FOLLOW_augassign_in_expr_stmt1753); + aat=augassign(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, aat.getTree()); + pushFollow(FOLLOW_testlist_in_expr_stmt1757); + rhs=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, rhs.getTree()); + if ( state.backtracking==0 ) { + + actions.checkAugAssign(actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null))); + stype = new AugAssign((lhs!=null?((PythonTree)lhs.tree):null), actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null)), (aat!=null?aat.op:null), actions.castExpr((rhs!=null?((PythonTree)rhs.tree):null))); + + } + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:657:7: ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) + { + pushFollow(FOLLOW_testlist_in_expr_stmt1812); + lhs=testlist(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, lhs.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:658:9: ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) + int alt34=3; + int LA34_0 = input.LA(1); + + if ( (LA34_0==NEWLINE||LA34_0==SEMI) ) { + alt34=1; + } + else if ( (LA34_0==ASSIGN) ) { + int LA34_2 = input.LA(2); + + if ( (LA34_2==YIELD) ) { + alt34=3; + } + else if ( (LA34_2==NAME||LA34_2==PRINT||(LA34_2>=LAMBDA && LA34_2<=NOT)||LA34_2==LPAREN||(LA34_2>=PLUS && LA34_2<=MINUS)||(LA34_2>=TILDE && LA34_2<=LBRACK)||LA34_2==LCURLY||(LA34_2>=BACKQUOTE && LA34_2<=STRING)) ) { + alt34=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 34, 2, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 34, 0, input); + + throw nvae; + } + switch (alt34) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:9: + { + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:11: ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:11: ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:12: (at= ASSIGN t+= testlist[expr_contextType.Store] )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:12: (at= ASSIGN t+= testlist[expr_contextType.Store] )+ + int cnt32=0; + loop32: + do { + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==ASSIGN) ) { + alt32=1; + } + + + switch (alt32) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:659:13: at= ASSIGN t+= testlist[expr_contextType.Store] + { + at=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_expr_stmt1839); if (state.failed) return retval; + if ( state.backtracking==0 ) { + at_tree = (PythonTree)adaptor.create(at); + adaptor.addChild(root_0, at_tree); + } + pushFollow(FOLLOW_testlist_in_expr_stmt1843); + t=testlist(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + if ( cnt32 >= 1 ) break loop32; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(32, input); + throw eee; + } + cnt32++; + } while (true); + + if ( state.backtracking==0 ) { + + stype = new Assign((lhs!=null?((PythonTree)lhs.tree):null), actions.makeAssignTargets( + actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null)), list_t), actions.makeAssignValue(list_t)); + + } + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:665:11: ( (ay= ASSIGN y2+= yield_expr )+ ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:665:11: ( (ay= ASSIGN y2+= yield_expr )+ ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:665:12: (ay= ASSIGN y2+= yield_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:665:12: (ay= ASSIGN y2+= yield_expr )+ + int cnt33=0; + loop33: + do { + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==ASSIGN) ) { + alt33=1; + } + + + switch (alt33) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:665:13: ay= ASSIGN y2+= yield_expr + { + ay=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_expr_stmt1888); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ay_tree = (PythonTree)adaptor.create(ay); + adaptor.addChild(root_0, ay_tree); + } + pushFollow(FOLLOW_yield_expr_in_expr_stmt1892); + y2=yield_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, y2.getTree()); + if (list_y2==null) list_y2=new ArrayList(); + list_y2.add(y2.getTree()); + + + } + break; + + default : + if ( cnt33 >= 1 ) break loop33; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(33, input); + throw eee; + } + cnt33++; + } while (true); + + if ( state.backtracking==0 ) { + + stype = new Assign((lhs!=null?((Token)lhs.start):null), actions.makeAssignTargets( + actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null)), list_y2), actions.makeAssignValue(list_y2)); + + } + + } + + + } + break; + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:672:7: lhs= testlist[expr_contextType.Load] + { + pushFollow(FOLLOW_testlist_in_expr_stmt1940); + lhs=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, lhs.getTree()); + if ( state.backtracking==0 ) { + + stype = new Expr((lhs!=null?((Token)lhs.start):null), actions.castExpr((lhs!=null?((PythonTree)lhs.tree):null))); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (stype != null) { + retval.tree = stype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "expr_stmt" + + public static class augassign_return extends ParserRuleReturnScope { + public operatorType op; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "augassign" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:681:1: augassign returns [operatorType op] : ( PLUSEQUAL | MINUSEQUAL | STAREQUAL | SLASHEQUAL | PERCENTEQUAL | AMPEREQUAL | VBAREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL ); + public final PythonParser.augassign_return augassign() throws RecognitionException { + PythonParser.augassign_return retval = new PythonParser.augassign_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token PLUSEQUAL72=null; + Token MINUSEQUAL73=null; + Token STAREQUAL74=null; + Token SLASHEQUAL75=null; + Token PERCENTEQUAL76=null; + Token AMPEREQUAL77=null; + Token VBAREQUAL78=null; + Token CIRCUMFLEXEQUAL79=null; + Token LEFTSHIFTEQUAL80=null; + Token RIGHTSHIFTEQUAL81=null; + Token DOUBLESTAREQUAL82=null; + Token DOUBLESLASHEQUAL83=null; + + PythonTree PLUSEQUAL72_tree=null; + PythonTree MINUSEQUAL73_tree=null; + PythonTree STAREQUAL74_tree=null; + PythonTree SLASHEQUAL75_tree=null; + PythonTree PERCENTEQUAL76_tree=null; + PythonTree AMPEREQUAL77_tree=null; + PythonTree VBAREQUAL78_tree=null; + PythonTree CIRCUMFLEXEQUAL79_tree=null; + PythonTree LEFTSHIFTEQUAL80_tree=null; + PythonTree RIGHTSHIFTEQUAL81_tree=null; + PythonTree DOUBLESTAREQUAL82_tree=null; + PythonTree DOUBLESLASHEQUAL83_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:683:5: ( PLUSEQUAL | MINUSEQUAL | STAREQUAL | SLASHEQUAL | PERCENTEQUAL | AMPEREQUAL | VBAREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL ) + int alt36=12; + switch ( input.LA(1) ) { + case PLUSEQUAL: + { + alt36=1; + } + break; + case MINUSEQUAL: + { + alt36=2; + } + break; + case STAREQUAL: + { + alt36=3; + } + break; + case SLASHEQUAL: + { + alt36=4; + } + break; + case PERCENTEQUAL: + { + alt36=5; + } + break; + case AMPEREQUAL: + { + alt36=6; + } + break; + case VBAREQUAL: + { + alt36=7; + } + break; + case CIRCUMFLEXEQUAL: + { + alt36=8; + } + break; + case LEFTSHIFTEQUAL: + { + alt36=9; + } + break; + case RIGHTSHIFTEQUAL: + { + alt36=10; + } + break; + case DOUBLESTAREQUAL: + { + alt36=11; + } + break; + case DOUBLESLASHEQUAL: + { + alt36=12; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 36, 0, input); + + throw nvae; + } + + switch (alt36) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:683:7: PLUSEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + PLUSEQUAL72=(Token)match(input,PLUSEQUAL,FOLLOW_PLUSEQUAL_in_augassign1982); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PLUSEQUAL72_tree = (PythonTree)adaptor.create(PLUSEQUAL72); + adaptor.addChild(root_0, PLUSEQUAL72_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Add; + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:687:7: MINUSEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + MINUSEQUAL73=(Token)match(input,MINUSEQUAL,FOLLOW_MINUSEQUAL_in_augassign2000); if (state.failed) return retval; + if ( state.backtracking==0 ) { + MINUSEQUAL73_tree = (PythonTree)adaptor.create(MINUSEQUAL73); + adaptor.addChild(root_0, MINUSEQUAL73_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Sub; + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:691:7: STAREQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + STAREQUAL74=(Token)match(input,STAREQUAL,FOLLOW_STAREQUAL_in_augassign2018); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAREQUAL74_tree = (PythonTree)adaptor.create(STAREQUAL74); + adaptor.addChild(root_0, STAREQUAL74_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Mult; + + } + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:695:7: SLASHEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + SLASHEQUAL75=(Token)match(input,SLASHEQUAL,FOLLOW_SLASHEQUAL_in_augassign2036); if (state.failed) return retval; + if ( state.backtracking==0 ) { + SLASHEQUAL75_tree = (PythonTree)adaptor.create(SLASHEQUAL75); + adaptor.addChild(root_0, SLASHEQUAL75_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Div; + + } + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:699:7: PERCENTEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + PERCENTEQUAL76=(Token)match(input,PERCENTEQUAL,FOLLOW_PERCENTEQUAL_in_augassign2054); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PERCENTEQUAL76_tree = (PythonTree)adaptor.create(PERCENTEQUAL76); + adaptor.addChild(root_0, PERCENTEQUAL76_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Mod; + + } + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:703:7: AMPEREQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + AMPEREQUAL77=(Token)match(input,AMPEREQUAL,FOLLOW_AMPEREQUAL_in_augassign2072); if (state.failed) return retval; + if ( state.backtracking==0 ) { + AMPEREQUAL77_tree = (PythonTree)adaptor.create(AMPEREQUAL77); + adaptor.addChild(root_0, AMPEREQUAL77_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.BitAnd; + + } + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:707:7: VBAREQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + VBAREQUAL78=(Token)match(input,VBAREQUAL,FOLLOW_VBAREQUAL_in_augassign2090); if (state.failed) return retval; + if ( state.backtracking==0 ) { + VBAREQUAL78_tree = (PythonTree)adaptor.create(VBAREQUAL78); + adaptor.addChild(root_0, VBAREQUAL78_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.BitOr; + + } + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:711:7: CIRCUMFLEXEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + CIRCUMFLEXEQUAL79=(Token)match(input,CIRCUMFLEXEQUAL,FOLLOW_CIRCUMFLEXEQUAL_in_augassign2108); if (state.failed) return retval; + if ( state.backtracking==0 ) { + CIRCUMFLEXEQUAL79_tree = (PythonTree)adaptor.create(CIRCUMFLEXEQUAL79); + adaptor.addChild(root_0, CIRCUMFLEXEQUAL79_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.BitXor; + + } + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:715:7: LEFTSHIFTEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + LEFTSHIFTEQUAL80=(Token)match(input,LEFTSHIFTEQUAL,FOLLOW_LEFTSHIFTEQUAL_in_augassign2126); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LEFTSHIFTEQUAL80_tree = (PythonTree)adaptor.create(LEFTSHIFTEQUAL80); + adaptor.addChild(root_0, LEFTSHIFTEQUAL80_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.LShift; + + } + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:719:7: RIGHTSHIFTEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + RIGHTSHIFTEQUAL81=(Token)match(input,RIGHTSHIFTEQUAL,FOLLOW_RIGHTSHIFTEQUAL_in_augassign2144); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RIGHTSHIFTEQUAL81_tree = (PythonTree)adaptor.create(RIGHTSHIFTEQUAL81); + adaptor.addChild(root_0, RIGHTSHIFTEQUAL81_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.RShift; + + } + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:723:7: DOUBLESTAREQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + DOUBLESTAREQUAL82=(Token)match(input,DOUBLESTAREQUAL,FOLLOW_DOUBLESTAREQUAL_in_augassign2162); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAREQUAL82_tree = (PythonTree)adaptor.create(DOUBLESTAREQUAL82); + adaptor.addChild(root_0, DOUBLESTAREQUAL82_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Pow; + + } + + } + break; + case 12 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:727:7: DOUBLESLASHEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + DOUBLESLASHEQUAL83=(Token)match(input,DOUBLESLASHEQUAL,FOLLOW_DOUBLESLASHEQUAL_in_augassign2180); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESLASHEQUAL83_tree = (PythonTree)adaptor.create(DOUBLESLASHEQUAL83); + adaptor.addChild(root_0, DOUBLESLASHEQUAL83_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.FloorDiv; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "augassign" + + public static class print_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "print_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:735:1: print_stmt : PRINT (t1= printlist | RIGHTSHIFT t2= printlist2 | ) ; + public final PythonParser.print_stmt_return print_stmt() throws RecognitionException { + PythonParser.print_stmt_return retval = new PythonParser.print_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token PRINT84=null; + Token RIGHTSHIFT85=null; + PythonParser.printlist_return t1 = null; + + PythonParser.printlist2_return t2 = null; + + + PythonTree PRINT84_tree=null; + PythonTree RIGHTSHIFT85_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:743:5: ( PRINT (t1= printlist | RIGHTSHIFT t2= printlist2 | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:743:7: PRINT (t1= printlist | RIGHTSHIFT t2= printlist2 | ) + { + root_0 = (PythonTree)adaptor.nil(); + + PRINT84=(Token)match(input,PRINT,FOLLOW_PRINT_in_print_stmt2220); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PRINT84_tree = (PythonTree)adaptor.create(PRINT84); + adaptor.addChild(root_0, PRINT84_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:744:7: (t1= printlist | RIGHTSHIFT t2= printlist2 | ) + int alt37=3; + int LA37_0 = input.LA(1); + + if ( (LA37_0==NAME||LA37_0==NOT||LA37_0==LPAREN||(LA37_0>=PLUS && LA37_0<=MINUS)||(LA37_0>=TILDE && LA37_0<=LBRACK)||LA37_0==LCURLY||LA37_0==BACKQUOTE) ) { + alt37=1; + } + else if ( (LA37_0==PRINT) && ((printFunction))) { + alt37=1; + } + else if ( (LA37_0==LAMBDA||(LA37_0>=INT && LA37_0<=STRING)) ) { + alt37=1; + } + else if ( (LA37_0==RIGHTSHIFT) ) { + alt37=2; + } + else if ( (LA37_0==NEWLINE||LA37_0==SEMI) ) { + alt37=3; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); + + throw nvae; + } + switch (alt37) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:744:8: t1= printlist + { + pushFollow(FOLLOW_printlist_in_print_stmt2231); + t1=printlist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + if ( state.backtracking==0 ) { + + stype = new Print(PRINT84, null, actions.castExprs((t1!=null?t1.elts:null)), (t1!=null?t1.newline:false)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:748:9: RIGHTSHIFT t2= printlist2 + { + RIGHTSHIFT85=(Token)match(input,RIGHTSHIFT,FOLLOW_RIGHTSHIFT_in_print_stmt2250); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RIGHTSHIFT85_tree = (PythonTree)adaptor.create(RIGHTSHIFT85); + adaptor.addChild(root_0, RIGHTSHIFT85_tree); + } + pushFollow(FOLLOW_printlist2_in_print_stmt2254); + t2=printlist2(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + if ( state.backtracking==0 ) { + + stype = new Print(PRINT84, actions.castExpr((t2!=null?t2.elts:null).get(0)), actions.castExprs((t2!=null?t2.elts:null), 1), (t2!=null?t2.newline:false)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:753:8: + { + if ( state.backtracking==0 ) { + + stype = new Print(PRINT84, null, new ArrayList(), true); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "print_stmt" + + public static class printlist_return extends ParserRuleReturnScope { + public boolean newline; + public List elts; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "printlist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:760:1: printlist returns [boolean newline, List elts] : ( ( test[null] COMMA )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] ); + public final PythonParser.printlist_return printlist() throws RecognitionException { + PythonParser.printlist_return retval = new PythonParser.printlist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token trailcomma=null; + Token COMMA86=null; + List list_t=null; + PythonParser.test_return t = null; + t = null; + PythonTree trailcomma_tree=null; + PythonTree COMMA86_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:762:5: ( ( test[null] COMMA )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] ) + int alt40=2; + alt40 = dfa40.predict(input); + switch (alt40) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:762:7: ( test[null] COMMA )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_printlist2334); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:763:39: ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* + loop38: + do { + int alt38=2; + alt38 = dfa38.predict(input); + switch (alt38) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:763:56: COMMA t+= test[expr_contextType.Load] + { + COMMA86=(Token)match(input,COMMA,FOLLOW_COMMA_in_printlist2346); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA86_tree = (PythonTree)adaptor.create(COMMA86); + adaptor.addChild(root_0, COMMA86_tree); + } + pushFollow(FOLLOW_test_in_printlist2350); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop38; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:763:95: (trailcomma= COMMA )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==COMMA) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:763:96: trailcomma= COMMA + { + trailcomma=(Token)match(input,COMMA,FOLLOW_COMMA_in_printlist2358); if (state.failed) return retval; + if ( state.backtracking==0 ) { + trailcomma_tree = (PythonTree)adaptor.create(trailcomma); + adaptor.addChild(root_0, trailcomma_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.elts =list_t; + if (trailcomma == null) { + retval.newline = true; + } else { + retval.newline = false; + } + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:772:7: t+= test[expr_contextType.Load] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_printlist2379); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + if ( state.backtracking==0 ) { + + retval.elts =list_t; + retval.newline = true; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "printlist" + + public static class printlist2_return extends ParserRuleReturnScope { + public boolean newline; + public List elts; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "printlist2" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:781:1: printlist2 returns [boolean newline, List elts] : ( ( test[null] COMMA test[null] )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] ); + public final PythonParser.printlist2_return printlist2() throws RecognitionException { + PythonParser.printlist2_return retval = new PythonParser.printlist2_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token trailcomma=null; + Token COMMA87=null; + List list_t=null; + PythonParser.test_return t = null; + t = null; + PythonTree trailcomma_tree=null; + PythonTree COMMA87_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:783:5: ( ( test[null] COMMA test[null] )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] ) + int alt43=2; + alt43 = dfa43.predict(input); + switch (alt43) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:783:7: ( test[null] COMMA test[null] )=>t+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_printlist22436); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:784:39: ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* + loop41: + do { + int alt41=2; + alt41 = dfa41.predict(input); + switch (alt41) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:784:56: COMMA t+= test[expr_contextType.Load] + { + COMMA87=(Token)match(input,COMMA,FOLLOW_COMMA_in_printlist22448); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA87_tree = (PythonTree)adaptor.create(COMMA87); + adaptor.addChild(root_0, COMMA87_tree); + } + pushFollow(FOLLOW_test_in_printlist22452); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop41; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:784:95: (trailcomma= COMMA )? + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==COMMA) ) { + alt42=1; + } + switch (alt42) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:784:96: trailcomma= COMMA + { + trailcomma=(Token)match(input,COMMA,FOLLOW_COMMA_in_printlist22460); if (state.failed) return retval; + if ( state.backtracking==0 ) { + trailcomma_tree = (PythonTree)adaptor.create(trailcomma); + adaptor.addChild(root_0, trailcomma_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + retval.elts =list_t; + if (trailcomma == null) { + retval.newline = true; + } else { + retval.newline = false; + } + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:792:7: t+= test[expr_contextType.Load] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_printlist22481); + t=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + if ( state.backtracking==0 ) { + + retval.elts =list_t; + retval.newline = true; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "printlist2" + + public static class del_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "del_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:800:1: del_stmt : DELETE del_list ; + public final PythonParser.del_stmt_return del_stmt() throws RecognitionException { + PythonParser.del_stmt_return retval = new PythonParser.del_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token DELETE88=null; + PythonParser.del_list_return del_list89 = null; + + + PythonTree DELETE88_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:807:5: ( DELETE del_list ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:807:7: DELETE del_list + { + root_0 = (PythonTree)adaptor.nil(); + + DELETE88=(Token)match(input,DELETE,FOLLOW_DELETE_in_del_stmt2518); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DELETE88_tree = (PythonTree)adaptor.create(DELETE88); + adaptor.addChild(root_0, DELETE88_tree); + } + pushFollow(FOLLOW_del_list_in_del_stmt2520); + del_list89=del_list(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, del_list89.getTree()); + if ( state.backtracking==0 ) { + + stype = new Delete(DELETE88, (del_list89!=null?del_list89.etypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "del_stmt" + + public static class pass_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "pass_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:814:1: pass_stmt : PASS ; + public final PythonParser.pass_stmt_return pass_stmt() throws RecognitionException { + PythonParser.pass_stmt_return retval = new PythonParser.pass_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token PASS90=null; + + PythonTree PASS90_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:821:5: ( PASS ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:821:7: PASS + { + root_0 = (PythonTree)adaptor.nil(); + + PASS90=(Token)match(input,PASS,FOLLOW_PASS_in_pass_stmt2556); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PASS90_tree = (PythonTree)adaptor.create(PASS90); + adaptor.addChild(root_0, PASS90_tree); + } + if ( state.backtracking==0 ) { + + stype = new Pass(PASS90); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "pass_stmt" + + public static class flow_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "flow_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:828:1: flow_stmt : ( break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt ); + public final PythonParser.flow_stmt_return flow_stmt() throws RecognitionException { + PythonParser.flow_stmt_return retval = new PythonParser.flow_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.break_stmt_return break_stmt91 = null; + + PythonParser.continue_stmt_return continue_stmt92 = null; + + PythonParser.return_stmt_return return_stmt93 = null; + + PythonParser.raise_stmt_return raise_stmt94 = null; + + PythonParser.yield_stmt_return yield_stmt95 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:829:5: ( break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt ) + int alt44=5; + switch ( input.LA(1) ) { + case BREAK: + { + alt44=1; + } + break; + case CONTINUE: + { + alt44=2; + } + break; + case RETURN: + { + alt44=3; + } + break; + case RAISE: + { + alt44=4; + } + break; + case YIELD: + { + alt44=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 44, 0, input); + + throw nvae; + } + + switch (alt44) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:829:7: break_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_break_stmt_in_flow_stmt2582); + break_stmt91=break_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, break_stmt91.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:830:7: continue_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_continue_stmt_in_flow_stmt2590); + continue_stmt92=continue_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, continue_stmt92.getTree()); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:831:7: return_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_return_stmt_in_flow_stmt2598); + return_stmt93=return_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, return_stmt93.getTree()); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:832:7: raise_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_raise_stmt_in_flow_stmt2606); + raise_stmt94=raise_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, raise_stmt94.getTree()); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:833:7: yield_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_yield_stmt_in_flow_stmt2614); + yield_stmt95=yield_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, yield_stmt95.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "flow_stmt" + + public static class break_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "break_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:837:1: break_stmt : BREAK ; + public final PythonParser.break_stmt_return break_stmt() throws RecognitionException { + PythonParser.break_stmt_return retval = new PythonParser.break_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token BREAK96=null; + + PythonTree BREAK96_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:844:5: ( BREAK ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:844:7: BREAK + { + root_0 = (PythonTree)adaptor.nil(); + + BREAK96=(Token)match(input,BREAK,FOLLOW_BREAK_in_break_stmt2642); if (state.failed) return retval; + if ( state.backtracking==0 ) { + BREAK96_tree = (PythonTree)adaptor.create(BREAK96); + adaptor.addChild(root_0, BREAK96_tree); + } + if ( state.backtracking==0 ) { + + stype = new Break(BREAK96); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "break_stmt" + + public static class continue_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "continue_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:851:1: continue_stmt : CONTINUE ; + public final PythonParser.continue_stmt_return continue_stmt() throws RecognitionException { + PythonParser.continue_stmt_return retval = new PythonParser.continue_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token CONTINUE97=null; + + PythonTree CONTINUE97_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:858:5: ( CONTINUE ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:858:7: CONTINUE + { + root_0 = (PythonTree)adaptor.nil(); + + CONTINUE97=(Token)match(input,CONTINUE,FOLLOW_CONTINUE_in_continue_stmt2678); if (state.failed) return retval; + if ( state.backtracking==0 ) { + CONTINUE97_tree = (PythonTree)adaptor.create(CONTINUE97); + adaptor.addChild(root_0, CONTINUE97_tree); + } + if ( state.backtracking==0 ) { + + if (!suite_stack.isEmpty() && ((suite_scope)suite_stack.peek()).continueIllegal) { + errorHandler.error("'continue' not supported inside 'finally' clause", new PythonTree(((Token)retval.start))); + } + stype = new Continue(CONTINUE97); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "continue_stmt" + + public static class return_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "return_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:868:1: return_stmt : RETURN ( testlist[expr_contextType.Load] | ) ; + public final PythonParser.return_stmt_return return_stmt() throws RecognitionException { + PythonParser.return_stmt_return retval = new PythonParser.return_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token RETURN98=null; + PythonParser.testlist_return testlist99 = null; + + + PythonTree RETURN98_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:875:5: ( RETURN ( testlist[expr_contextType.Load] | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:875:7: RETURN ( testlist[expr_contextType.Load] | ) + { + root_0 = (PythonTree)adaptor.nil(); + + RETURN98=(Token)match(input,RETURN,FOLLOW_RETURN_in_return_stmt2714); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RETURN98_tree = (PythonTree)adaptor.create(RETURN98); + adaptor.addChild(root_0, RETURN98_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:876:7: ( testlist[expr_contextType.Load] | ) + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==NAME||LA45_0==NOT||LA45_0==LPAREN||(LA45_0>=PLUS && LA45_0<=MINUS)||(LA45_0>=TILDE && LA45_0<=LBRACK)||LA45_0==LCURLY||LA45_0==BACKQUOTE) ) { + alt45=1; + } + else if ( (LA45_0==PRINT) && ((printFunction))) { + alt45=1; + } + else if ( (LA45_0==LAMBDA||(LA45_0>=INT && LA45_0<=STRING)) ) { + alt45=1; + } + else if ( (LA45_0==NEWLINE||LA45_0==SEMI) ) { + alt45=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 45, 0, input); + + throw nvae; + } + switch (alt45) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:876:8: testlist[expr_contextType.Load] + { + pushFollow(FOLLOW_testlist_in_return_stmt2723); + testlist99=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist99.getTree()); + if ( state.backtracking==0 ) { + + stype = new Return(RETURN98, actions.castExpr((testlist99!=null?((PythonTree)testlist99.tree):null))); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:881:8: + { + if ( state.backtracking==0 ) { + + stype = new Return(RETURN98, null); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "return_stmt" + + public static class yield_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "yield_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:888:1: yield_stmt : yield_expr ; + public final PythonParser.yield_stmt_return yield_stmt() throws RecognitionException { + PythonParser.yield_stmt_return retval = new PythonParser.yield_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.yield_expr_return yield_expr100 = null; + + + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:895:5: ( yield_expr ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:895:7: yield_expr + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_yield_expr_in_yield_stmt2788); + yield_expr100=yield_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, yield_expr100.getTree()); + if ( state.backtracking==0 ) { + + stype = new Expr((yield_expr100!=null?((Token)yield_expr100.start):null), actions.castExpr((yield_expr100!=null?yield_expr100.etype:null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "yield_stmt" + + public static class raise_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "raise_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:902:1: raise_stmt : RAISE (t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? )? ; + public final PythonParser.raise_stmt_return raise_stmt() throws RecognitionException { + PythonParser.raise_stmt_return retval = new PythonParser.raise_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token RAISE101=null; + Token COMMA102=null; + Token COMMA103=null; + PythonParser.test_return t1 = null; + + PythonParser.test_return t2 = null; + + PythonParser.test_return t3 = null; + + + PythonTree RAISE101_tree=null; + PythonTree COMMA102_tree=null; + PythonTree COMMA103_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:5: ( RAISE (t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:7: RAISE (t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? )? + { + root_0 = (PythonTree)adaptor.nil(); + + RAISE101=(Token)match(input,RAISE,FOLLOW_RAISE_in_raise_stmt2824); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RAISE101_tree = (PythonTree)adaptor.create(RAISE101); + adaptor.addChild(root_0, RAISE101_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:13: (t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? )? + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==NAME||LA48_0==NOT||LA48_0==LPAREN||(LA48_0>=PLUS && LA48_0<=MINUS)||(LA48_0>=TILDE && LA48_0<=LBRACK)||LA48_0==LCURLY||LA48_0==BACKQUOTE) ) { + alt48=1; + } + else if ( (LA48_0==PRINT) && ((printFunction))) { + alt48=1; + } + else if ( (LA48_0==LAMBDA||(LA48_0>=INT && LA48_0<=STRING)) ) { + alt48=1; + } + switch (alt48) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:14: t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? + { + pushFollow(FOLLOW_test_in_raise_stmt2829); + t1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:45: ( COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? )? + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==COMMA) ) { + alt47=1; + } + switch (alt47) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:909:46: COMMA t2= test[expr_contextType.Load] ( COMMA t3= test[expr_contextType.Load] )? + { + COMMA102=(Token)match(input,COMMA,FOLLOW_COMMA_in_raise_stmt2833); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA102_tree = (PythonTree)adaptor.create(COMMA102); + adaptor.addChild(root_0, COMMA102_tree); + } + pushFollow(FOLLOW_test_in_raise_stmt2837); + t2=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:910:9: ( COMMA t3= test[expr_contextType.Load] )? + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==COMMA) ) { + alt46=1; + } + switch (alt46) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:910:10: COMMA t3= test[expr_contextType.Load] + { + COMMA103=(Token)match(input,COMMA,FOLLOW_COMMA_in_raise_stmt2849); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA103_tree = (PythonTree)adaptor.create(COMMA103); + adaptor.addChild(root_0, COMMA103_tree); + } + pushFollow(FOLLOW_test_in_raise_stmt2853); + t3=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t3.getTree()); + + } + break; + + } + + + } + break; + + } + + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = new Raise(RAISE101, actions.castExpr((t1!=null?((PythonTree)t1.tree):null)), actions.castExpr((t2!=null?((PythonTree)t2.tree):null)), actions.castExpr((t3!=null?((PythonTree)t3.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "raise_stmt" + + public static class import_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "import_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:917:1: import_stmt : ( import_name | import_from ); + public final PythonParser.import_stmt_return import_stmt() throws RecognitionException { + PythonParser.import_stmt_return retval = new PythonParser.import_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.import_name_return import_name104 = null; + + PythonParser.import_from_return import_from105 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:918:5: ( import_name | import_from ) + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==IMPORT) ) { + alt49=1; + } + else if ( (LA49_0==FROM) ) { + alt49=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 49, 0, input); + + throw nvae; + } + switch (alt49) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:918:7: import_name + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_import_name_in_import_stmt2886); + import_name104=import_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, import_name104.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:919:7: import_from + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_import_from_in_import_stmt2894); + import_from105=import_from(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, import_from105.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "import_stmt" + + public static class import_name_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "import_name" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:923:1: import_name : IMPORT dotted_as_names ; + public final PythonParser.import_name_return import_name() throws RecognitionException { + PythonParser.import_name_return retval = new PythonParser.import_name_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token IMPORT106=null; + PythonParser.dotted_as_names_return dotted_as_names107 = null; + + + PythonTree IMPORT106_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:930:5: ( IMPORT dotted_as_names ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:930:7: IMPORT dotted_as_names + { + root_0 = (PythonTree)adaptor.nil(); + + IMPORT106=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_import_name2922); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IMPORT106_tree = (PythonTree)adaptor.create(IMPORT106); + adaptor.addChild(root_0, IMPORT106_tree); + } + pushFollow(FOLLOW_dotted_as_names_in_import_name2924); + dotted_as_names107=dotted_as_names(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, dotted_as_names107.getTree()); + if ( state.backtracking==0 ) { + + stype = new Import(IMPORT106, (dotted_as_names107!=null?dotted_as_names107.atypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "import_name" + + public static class import_from_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "import_from" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:938:1: import_from : FROM ( (d+= DOT )* dotted_name | (d+= DOT )+ ) IMPORT ( STAR | i1= import_as_names | LPAREN i2= import_as_names ( COMMA )? RPAREN ) ; + public final PythonParser.import_from_return import_from() throws RecognitionException { + PythonParser.import_from_return retval = new PythonParser.import_from_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token FROM108=null; + Token IMPORT110=null; + Token STAR111=null; + Token LPAREN112=null; + Token COMMA113=null; + Token RPAREN114=null; + Token d=null; + List list_d=null; + PythonParser.import_as_names_return i1 = null; + + PythonParser.import_as_names_return i2 = null; + + PythonParser.dotted_name_return dotted_name109 = null; + + + PythonTree FROM108_tree=null; + PythonTree IMPORT110_tree=null; + PythonTree STAR111_tree=null; + PythonTree LPAREN112_tree=null; + PythonTree COMMA113_tree=null; + PythonTree RPAREN114_tree=null; + PythonTree d_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:5: ( FROM ( (d+= DOT )* dotted_name | (d+= DOT )+ ) IMPORT ( STAR | i1= import_as_names | LPAREN i2= import_as_names ( COMMA )? RPAREN ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:7: FROM ( (d+= DOT )* dotted_name | (d+= DOT )+ ) IMPORT ( STAR | i1= import_as_names | LPAREN i2= import_as_names ( COMMA )? RPAREN ) + { + root_0 = (PythonTree)adaptor.nil(); + + FROM108=(Token)match(input,FROM,FOLLOW_FROM_in_import_from2961); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FROM108_tree = (PythonTree)adaptor.create(FROM108); + adaptor.addChild(root_0, FROM108_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:12: ( (d+= DOT )* dotted_name | (d+= DOT )+ ) + int alt52=2; + alt52 = dfa52.predict(input); + switch (alt52) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:13: (d+= DOT )* dotted_name + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:14: (d+= DOT )* + loop50: + do { + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==DOT) ) { + alt50=1; + } + + + switch (alt50) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:14: d+= DOT + { + d=(Token)match(input,DOT,FOLLOW_DOT_in_import_from2966); if (state.failed) return retval; + if ( state.backtracking==0 ) { + d_tree = (PythonTree)adaptor.create(d); + adaptor.addChild(root_0, d_tree); + } + if (list_d==null) list_d=new ArrayList(); + list_d.add(d); + + + } + break; + + default : + break loop50; + } + } while (true); + + pushFollow(FOLLOW_dotted_name_in_import_from2969); + dotted_name109=dotted_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, dotted_name109.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:35: (d+= DOT )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:36: (d+= DOT )+ + int cnt51=0; + loop51: + do { + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==DOT) ) { + alt51=1; + } + + + switch (alt51) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:945:36: d+= DOT + { + d=(Token)match(input,DOT,FOLLOW_DOT_in_import_from2975); if (state.failed) return retval; + if ( state.backtracking==0 ) { + d_tree = (PythonTree)adaptor.create(d); + adaptor.addChild(root_0, d_tree); + } + if (list_d==null) list_d=new ArrayList(); + list_d.add(d); + + + } + break; + + default : + if ( cnt51 >= 1 ) break loop51; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(51, input); + throw eee; + } + cnt51++; + } while (true); + + + } + break; + + } + + IMPORT110=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_import_from2979); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IMPORT110_tree = (PythonTree)adaptor.create(IMPORT110); + adaptor.addChild(root_0, IMPORT110_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:946:9: ( STAR | i1= import_as_names | LPAREN i2= import_as_names ( COMMA )? RPAREN ) + int alt54=3; + switch ( input.LA(1) ) { + case STAR: + { + alt54=1; + } + break; + case NAME: + { + alt54=2; + } + break; + case LPAREN: + { + alt54=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 54, 0, input); + + throw nvae; + } + + switch (alt54) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:946:10: STAR + { + STAR111=(Token)match(input,STAR,FOLLOW_STAR_in_import_from2990); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR111_tree = (PythonTree)adaptor.create(STAR111); + adaptor.addChild(root_0, STAR111_tree); + } + if ( state.backtracking==0 ) { + + stype = new ImportFrom(FROM108, actions.makeFromText(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeModuleNameNode(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeStarAlias(STAR111), actions.makeLevel(list_d)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:952:11: i1= import_as_names + { + pushFollow(FOLLOW_import_as_names_in_import_from3015); + i1=import_as_names(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, i1.getTree()); + if ( state.backtracking==0 ) { + + String dottedText = (dotted_name109!=null?input.toString(dotted_name109.start,dotted_name109.stop):null); + if (dottedText != null && dottedText.equals("__future__")) { + List aliases = (i1!=null?i1.atypes:null); + for(alias a: aliases) { + if (a != null) { + if (a.getInternalName().equals("print_function")) { + printFunction = true; + } else if (a.getInternalName().equals("unicode_literals")) { + unicodeLiterals = true; + } + } + } + } + stype = new ImportFrom(FROM108, actions.makeFromText(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeModuleNameNode(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeAliases((i1!=null?i1.atypes:null)), actions.makeLevel(list_d)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:971:11: LPAREN i2= import_as_names ( COMMA )? RPAREN + { + LPAREN112=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_import_from3038); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN112_tree = (PythonTree)adaptor.create(LPAREN112); + adaptor.addChild(root_0, LPAREN112_tree); + } + pushFollow(FOLLOW_import_as_names_in_import_from3042); + i2=import_as_names(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, i2.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:971:37: ( COMMA )? + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==COMMA) ) { + alt53=1; + } + switch (alt53) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:971:37: COMMA + { + COMMA113=(Token)match(input,COMMA,FOLLOW_COMMA_in_import_from3044); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA113_tree = (PythonTree)adaptor.create(COMMA113); + adaptor.addChild(root_0, COMMA113_tree); + } + + } + break; + + } + + RPAREN114=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_import_from3047); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN114_tree = (PythonTree)adaptor.create(RPAREN114); + adaptor.addChild(root_0, RPAREN114_tree); + } + if ( state.backtracking==0 ) { + + //XXX: this is almost a complete C&P of the code above - is there some way + // to factor it out? + String dottedText = (dotted_name109!=null?input.toString(dotted_name109.start,dotted_name109.stop):null); + if (dottedText != null && dottedText.equals("__future__")) { + List aliases = (i2!=null?i2.atypes:null); + for(alias a: aliases) { + if (a != null) { + if (a.getInternalName().equals("print_function")) { + printFunction = true; + } else if (a.getInternalName().equals("unicode_literals")) { + unicodeLiterals = true; + } + } + } + } + stype = new ImportFrom(FROM108, actions.makeFromText(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeModuleNameNode(list_d, (dotted_name109!=null?dotted_name109.names:null)), + actions.makeAliases((i2!=null?i2.atypes:null)), actions.makeLevel(list_d)); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "import_from" + + public static class import_as_names_return extends ParserRuleReturnScope { + public List atypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "import_as_names" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:996:1: import_as_names returns [List atypes] : n+= import_as_name ( COMMA n+= import_as_name )* ; + public final PythonParser.import_as_names_return import_as_names() throws RecognitionException { + PythonParser.import_as_names_return retval = new PythonParser.import_as_names_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA115=null; + List list_n=null; + PythonParser.import_as_name_return n = null; + n = null; + PythonTree COMMA115_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:998:5: (n+= import_as_name ( COMMA n+= import_as_name )* ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:998:7: n+= import_as_name ( COMMA n+= import_as_name )* + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_import_as_name_in_import_as_names3096); + n=import_as_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, n.getTree()); + if (list_n==null) list_n=new ArrayList(); + list_n.add(n.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:998:25: ( COMMA n+= import_as_name )* + loop55: + do { + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==COMMA) ) { + int LA55_2 = input.LA(2); + + if ( (LA55_2==NAME) ) { + alt55=1; + } + + + } + + + switch (alt55) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:998:26: COMMA n+= import_as_name + { + COMMA115=(Token)match(input,COMMA,FOLLOW_COMMA_in_import_as_names3099); if (state.failed) return retval; + pushFollow(FOLLOW_import_as_name_in_import_as_names3104); + n=import_as_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, n.getTree()); + if (list_n==null) list_n=new ArrayList(); + list_n.add(n.getTree()); + + + } + break; + + default : + break loop55; + } + } while (true); + + if ( state.backtracking==0 ) { + + retval.atypes = list_n; + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "import_as_names" + + public static class import_as_name_return extends ParserRuleReturnScope { + public alias atype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "import_as_name" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1005:1: import_as_name returns [alias atype] : name= NAME ( AS asname= NAME )? ; + public final PythonParser.import_as_name_return import_as_name() throws RecognitionException { + PythonParser.import_as_name_return retval = new PythonParser.import_as_name_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token name=null; + Token asname=null; + Token AS116=null; + + PythonTree name_tree=null; + PythonTree asname_tree=null; + PythonTree AS116_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1010:5: (name= NAME ( AS asname= NAME )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1010:7: name= NAME ( AS asname= NAME )? + { + root_0 = (PythonTree)adaptor.nil(); + + name=(Token)match(input,NAME,FOLLOW_NAME_in_import_as_name3145); if (state.failed) return retval; + if ( state.backtracking==0 ) { + name_tree = (PythonTree)adaptor.create(name); + adaptor.addChild(root_0, name_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1010:17: ( AS asname= NAME )? + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==AS) ) { + alt56=1; + } + switch (alt56) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1010:18: AS asname= NAME + { + AS116=(Token)match(input,AS,FOLLOW_AS_in_import_as_name3148); if (state.failed) return retval; + if ( state.backtracking==0 ) { + AS116_tree = (PythonTree)adaptor.create(AS116); + adaptor.addChild(root_0, AS116_tree); + } + asname=(Token)match(input,NAME,FOLLOW_NAME_in_import_as_name3152); if (state.failed) return retval; + if ( state.backtracking==0 ) { + asname_tree = (PythonTree)adaptor.create(asname); + adaptor.addChild(root_0, asname_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.atype = new alias(actions.makeNameNode(name), actions.makeNameNode(asname)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.atype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "import_as_name" + + public static class dotted_as_name_return extends ParserRuleReturnScope { + public alias atype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "dotted_as_name" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1018:1: dotted_as_name returns [alias atype] : dotted_name ( AS asname= NAME )? ; + public final PythonParser.dotted_as_name_return dotted_as_name() throws RecognitionException { + PythonParser.dotted_as_name_return retval = new PythonParser.dotted_as_name_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token asname=null; + Token AS118=null; + PythonParser.dotted_name_return dotted_name117 = null; + + + PythonTree asname_tree=null; + PythonTree AS118_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1023:5: ( dotted_name ( AS asname= NAME )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1023:7: dotted_name ( AS asname= NAME )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_dotted_name_in_dotted_as_name3192); + dotted_name117=dotted_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, dotted_name117.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1023:19: ( AS asname= NAME )? + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==AS) ) { + alt57=1; + } + switch (alt57) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1023:20: AS asname= NAME + { + AS118=(Token)match(input,AS,FOLLOW_AS_in_dotted_as_name3195); if (state.failed) return retval; + if ( state.backtracking==0 ) { + AS118_tree = (PythonTree)adaptor.create(AS118); + adaptor.addChild(root_0, AS118_tree); + } + asname=(Token)match(input,NAME,FOLLOW_NAME_in_dotted_as_name3199); if (state.failed) return retval; + if ( state.backtracking==0 ) { + asname_tree = (PythonTree)adaptor.create(asname); + adaptor.addChild(root_0, asname_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.atype = new alias((dotted_name117!=null?dotted_name117.names:null), actions.makeNameNode(asname)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.atype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "dotted_as_name" + + public static class dotted_as_names_return extends ParserRuleReturnScope { + public List atypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "dotted_as_names" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1030:1: dotted_as_names returns [List atypes] : d+= dotted_as_name ( COMMA d+= dotted_as_name )* ; + public final PythonParser.dotted_as_names_return dotted_as_names() throws RecognitionException { + PythonParser.dotted_as_names_return retval = new PythonParser.dotted_as_names_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA119=null; + List list_d=null; + PythonParser.dotted_as_name_return d = null; + d = null; + PythonTree COMMA119_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1032:5: (d+= dotted_as_name ( COMMA d+= dotted_as_name )* ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1032:7: d+= dotted_as_name ( COMMA d+= dotted_as_name )* + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_dotted_as_name_in_dotted_as_names3235); + d=dotted_as_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree()); + if (list_d==null) list_d=new ArrayList(); + list_d.add(d.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1032:25: ( COMMA d+= dotted_as_name )* + loop58: + do { + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==COMMA) ) { + alt58=1; + } + + + switch (alt58) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1032:26: COMMA d+= dotted_as_name + { + COMMA119=(Token)match(input,COMMA,FOLLOW_COMMA_in_dotted_as_names3238); if (state.failed) return retval; + pushFollow(FOLLOW_dotted_as_name_in_dotted_as_names3243); + d=dotted_as_name(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree()); + if (list_d==null) list_d=new ArrayList(); + list_d.add(d.getTree()); + + + } + break; + + default : + break loop58; + } + } while (true); + + if ( state.backtracking==0 ) { + + retval.atypes = list_d; + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "dotted_as_names" + + public static class dotted_name_return extends ParserRuleReturnScope { + public List names; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "dotted_name" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1039:1: dotted_name returns [List names] : NAME ( DOT dn+= attr )* ; + public final PythonParser.dotted_name_return dotted_name() throws RecognitionException { + PythonParser.dotted_name_return retval = new PythonParser.dotted_name_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NAME120=null; + Token DOT121=null; + List list_dn=null; + PythonParser.attr_return dn = null; + dn = null; + PythonTree NAME120_tree=null; + PythonTree DOT121_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1041:5: ( NAME ( DOT dn+= attr )* ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1041:7: NAME ( DOT dn+= attr )* + { + root_0 = (PythonTree)adaptor.nil(); + + NAME120=(Token)match(input,NAME,FOLLOW_NAME_in_dotted_name3277); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NAME120_tree = (PythonTree)adaptor.create(NAME120); + adaptor.addChild(root_0, NAME120_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1041:12: ( DOT dn+= attr )* + loop59: + do { + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==DOT) ) { + alt59=1; + } + + + switch (alt59) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1041:13: DOT dn+= attr + { + DOT121=(Token)match(input,DOT,FOLLOW_DOT_in_dotted_name3280); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOT121_tree = (PythonTree)adaptor.create(DOT121); + adaptor.addChild(root_0, DOT121_tree); + } + pushFollow(FOLLOW_attr_in_dotted_name3284); + dn=attr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, dn.getTree()); + if (list_dn==null) list_dn=new ArrayList(); + list_dn.add(dn.getTree()); + + + } + break; + + default : + break loop59; + } + } while (true); + + if ( state.backtracking==0 ) { + + retval.names = actions.makeDottedName(NAME120, list_dn); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "dotted_name" + + public static class global_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "global_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1048:1: global_stmt : GLOBAL n+= NAME ( COMMA n+= NAME )* ; + public final PythonParser.global_stmt_return global_stmt() throws RecognitionException { + PythonParser.global_stmt_return retval = new PythonParser.global_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token GLOBAL122=null; + Token COMMA123=null; + Token n=null; + List list_n=null; + + PythonTree GLOBAL122_tree=null; + PythonTree COMMA123_tree=null; + PythonTree n_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1055:5: ( GLOBAL n+= NAME ( COMMA n+= NAME )* ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1055:7: GLOBAL n+= NAME ( COMMA n+= NAME )* + { + root_0 = (PythonTree)adaptor.nil(); + + GLOBAL122=(Token)match(input,GLOBAL,FOLLOW_GLOBAL_in_global_stmt3320); if (state.failed) return retval; + if ( state.backtracking==0 ) { + GLOBAL122_tree = (PythonTree)adaptor.create(GLOBAL122); + adaptor.addChild(root_0, GLOBAL122_tree); + } + n=(Token)match(input,NAME,FOLLOW_NAME_in_global_stmt3324); if (state.failed) return retval; + if ( state.backtracking==0 ) { + n_tree = (PythonTree)adaptor.create(n); + adaptor.addChild(root_0, n_tree); + } + if (list_n==null) list_n=new ArrayList(); + list_n.add(n); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1055:22: ( COMMA n+= NAME )* + loop60: + do { + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==COMMA) ) { + alt60=1; + } + + + switch (alt60) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1055:23: COMMA n+= NAME + { + COMMA123=(Token)match(input,COMMA,FOLLOW_COMMA_in_global_stmt3327); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA123_tree = (PythonTree)adaptor.create(COMMA123); + adaptor.addChild(root_0, COMMA123_tree); + } + n=(Token)match(input,NAME,FOLLOW_NAME_in_global_stmt3331); if (state.failed) return retval; + if ( state.backtracking==0 ) { + n_tree = (PythonTree)adaptor.create(n); + adaptor.addChild(root_0, n_tree); + } + if (list_n==null) list_n=new ArrayList(); + list_n.add(n); + + + } + break; + + default : + break loop60; + } + } while (true); + + if ( state.backtracking==0 ) { + + stype = new Global(GLOBAL122, actions.makeNames(list_n), actions.makeNameNodes(list_n)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "global_stmt" + + public static class exec_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "exec_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1062:1: exec_stmt : EXEC expr[expr_contextType.Load] ( IN t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? )? ; + public final PythonParser.exec_stmt_return exec_stmt() throws RecognitionException { + PythonParser.exec_stmt_return retval = new PythonParser.exec_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token EXEC124=null; + Token IN126=null; + Token COMMA127=null; + PythonParser.test_return t1 = null; + + PythonParser.test_return t2 = null; + + PythonParser.expr_return expr125 = null; + + + PythonTree EXEC124_tree=null; + PythonTree IN126_tree=null; + PythonTree COMMA127_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:5: ( EXEC expr[expr_contextType.Load] ( IN t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:7: EXEC expr[expr_contextType.Load] ( IN t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? )? + { + root_0 = (PythonTree)adaptor.nil(); + + EXEC124=(Token)match(input,EXEC,FOLLOW_EXEC_in_exec_stmt3369); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EXEC124_tree = (PythonTree)adaptor.create(EXEC124); + adaptor.addChild(root_0, EXEC124_tree); + } + pushFollow(FOLLOW_expr_in_exec_stmt3371); + expr125=expr(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, expr125.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:40: ( IN t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? )? + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==IN) ) { + alt62=1; + } + switch (alt62) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:41: IN t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? + { + IN126=(Token)match(input,IN,FOLLOW_IN_in_exec_stmt3375); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN126_tree = (PythonTree)adaptor.create(IN126); + adaptor.addChild(root_0, IN126_tree); + } + pushFollow(FOLLOW_test_in_exec_stmt3379); + t1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:75: ( COMMA t2= test[expr_contextType.Load] )? + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==COMMA) ) { + alt61=1; + } + switch (alt61) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1069:76: COMMA t2= test[expr_contextType.Load] + { + COMMA127=(Token)match(input,COMMA,FOLLOW_COMMA_in_exec_stmt3383); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA127_tree = (PythonTree)adaptor.create(COMMA127); + adaptor.addChild(root_0, COMMA127_tree); + } + pushFollow(FOLLOW_test_in_exec_stmt3387); + t2=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + + } + break; + + } + + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = new Exec(EXEC124, actions.castExpr((expr125!=null?((PythonTree)expr125.tree):null)), actions.castExpr((t1!=null?((PythonTree)t1.tree):null)), actions.castExpr((t2!=null?((PythonTree)t2.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "exec_stmt" + + public static class assert_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "assert_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1076:1: assert_stmt : ASSERT t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? ; + public final PythonParser.assert_stmt_return assert_stmt() throws RecognitionException { + PythonParser.assert_stmt_return retval = new PythonParser.assert_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token ASSERT128=null; + Token COMMA129=null; + PythonParser.test_return t1 = null; + + PythonParser.test_return t2 = null; + + + PythonTree ASSERT128_tree=null; + PythonTree COMMA129_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1083:5: ( ASSERT t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1083:7: ASSERT t1= test[expr_contextType.Load] ( COMMA t2= test[expr_contextType.Load] )? + { + root_0 = (PythonTree)adaptor.nil(); + + ASSERT128=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_assert_stmt3428); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ASSERT128_tree = (PythonTree)adaptor.create(ASSERT128); + adaptor.addChild(root_0, ASSERT128_tree); + } + pushFollow(FOLLOW_test_in_assert_stmt3432); + t1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1083:45: ( COMMA t2= test[expr_contextType.Load] )? + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==COMMA) ) { + alt63=1; + } + switch (alt63) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1083:46: COMMA t2= test[expr_contextType.Load] + { + COMMA129=(Token)match(input,COMMA,FOLLOW_COMMA_in_assert_stmt3436); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA129_tree = (PythonTree)adaptor.create(COMMA129); + adaptor.addChild(root_0, COMMA129_tree); + } + pushFollow(FOLLOW_test_in_assert_stmt3440); + t2=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = new Assert(ASSERT128, actions.castExpr((t1!=null?((PythonTree)t1.tree):null)), actions.castExpr((t2!=null?((PythonTree)t2.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "assert_stmt" + + public static class compound_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "compound_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1090:1: compound_stmt : ( if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | ( ( decorators )? DEF )=> funcdef | classdef ); + public final PythonParser.compound_stmt_return compound_stmt() throws RecognitionException { + PythonParser.compound_stmt_return retval = new PythonParser.compound_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.if_stmt_return if_stmt130 = null; + + PythonParser.while_stmt_return while_stmt131 = null; + + PythonParser.for_stmt_return for_stmt132 = null; + + PythonParser.try_stmt_return try_stmt133 = null; + + PythonParser.with_stmt_return with_stmt134 = null; + + PythonParser.funcdef_return funcdef135 = null; + + PythonParser.classdef_return classdef136 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1091:5: ( if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | ( ( decorators )? DEF )=> funcdef | classdef ) + int alt64=7; + int LA64_0 = input.LA(1); + + if ( (LA64_0==IF) ) { + alt64=1; + } + else if ( (LA64_0==WHILE) ) { + alt64=2; + } + else if ( (LA64_0==FOR) ) { + alt64=3; + } + else if ( (LA64_0==TRY) ) { + alt64=4; + } + else if ( (LA64_0==WITH) ) { + alt64=5; + } + else if ( (LA64_0==AT) ) { + int LA64_6 = input.LA(2); + + if ( (synpred6_Python()) ) { + alt64=6; + } + else if ( (true) ) { + alt64=7; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 64, 6, input); + + throw nvae; + } + } + else if ( (LA64_0==DEF) && (synpred6_Python())) { + alt64=6; + } + else if ( (LA64_0==CLASS) ) { + alt64=7; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 64, 0, input); + + throw nvae; + } + switch (alt64) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1091:7: if_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_if_stmt_in_compound_stmt3469); + if_stmt130=if_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, if_stmt130.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1092:7: while_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_while_stmt_in_compound_stmt3477); + while_stmt131=while_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, while_stmt131.getTree()); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1093:7: for_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_for_stmt_in_compound_stmt3485); + for_stmt132=for_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, for_stmt132.getTree()); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1094:7: try_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_try_stmt_in_compound_stmt3493); + try_stmt133=try_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, try_stmt133.getTree()); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1095:7: with_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_with_stmt_in_compound_stmt3501); + with_stmt134=with_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, with_stmt134.getTree()); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1096:7: ( ( decorators )? DEF )=> funcdef + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_funcdef_in_compound_stmt3518); + funcdef135=funcdef(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, funcdef135.getTree()); + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1097:7: classdef + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_classdef_in_compound_stmt3526); + classdef136=classdef(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, classdef136.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "compound_stmt" + + public static class if_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "if_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1101:1: if_stmt : IF test[expr_contextType.Load] COLON ifsuite= suite[false] ( elif_clause )? ; + public final PythonParser.if_stmt_return if_stmt() throws RecognitionException { + PythonParser.if_stmt_return retval = new PythonParser.if_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token IF137=null; + Token COLON139=null; + PythonParser.suite_return ifsuite = null; + + PythonParser.test_return test138 = null; + + PythonParser.elif_clause_return elif_clause140 = null; + + + PythonTree IF137_tree=null; + PythonTree COLON139_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1108:5: ( IF test[expr_contextType.Load] COLON ifsuite= suite[false] ( elif_clause )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1108:7: IF test[expr_contextType.Load] COLON ifsuite= suite[false] ( elif_clause )? + { + root_0 = (PythonTree)adaptor.nil(); + + IF137=(Token)match(input,IF,FOLLOW_IF_in_if_stmt3554); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IF137_tree = (PythonTree)adaptor.create(IF137); + adaptor.addChild(root_0, IF137_tree); + } + pushFollow(FOLLOW_test_in_if_stmt3556); + test138=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test138.getTree()); + COLON139=(Token)match(input,COLON,FOLLOW_COLON_in_if_stmt3559); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON139_tree = (PythonTree)adaptor.create(COLON139); + adaptor.addChild(root_0, COLON139_tree); + } + pushFollow(FOLLOW_suite_in_if_stmt3563); + ifsuite=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, ifsuite.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1108:65: ( elif_clause )? + int alt65=2; + int LA65_0 = input.LA(1); + + if ( (LA65_0==ELIF||LA65_0==ORELSE) ) { + alt65=1; + } + switch (alt65) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1108:65: elif_clause + { + pushFollow(FOLLOW_elif_clause_in_if_stmt3566); + elif_clause140=elif_clause(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, elif_clause140.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = new If(IF137, actions.castExpr((test138!=null?((PythonTree)test138.tree):null)), actions.castStmts((ifsuite!=null?ifsuite.stypes:null)), + actions.makeElse((elif_clause140!=null?elif_clause140.stypes:null), (elif_clause140!=null?((PythonTree)elif_clause140.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "if_stmt" + + public static class elif_clause_return extends ParserRuleReturnScope { + public List stypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "elif_clause" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1116:1: elif_clause returns [List stypes] : ( else_clause | ELIF test[expr_contextType.Load] COLON suite[false] (e2= elif_clause | ) ); + public final PythonParser.elif_clause_return elif_clause() throws RecognitionException { + PythonParser.elif_clause_return retval = new PythonParser.elif_clause_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token ELIF142=null; + Token COLON144=null; + PythonParser.elif_clause_return e2 = null; + + PythonParser.else_clause_return else_clause141 = null; + + PythonParser.test_return test143 = null; + + PythonParser.suite_return suite145 = null; + + + PythonTree ELIF142_tree=null; + PythonTree COLON144_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1126:5: ( else_clause | ELIF test[expr_contextType.Load] COLON suite[false] (e2= elif_clause | ) ) + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==ORELSE) ) { + alt67=1; + } + else if ( (LA67_0==ELIF) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 67, 0, input); + + throw nvae; + } + switch (alt67) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1126:7: else_clause + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_else_clause_in_elif_clause3611); + else_clause141=else_clause(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, else_clause141.getTree()); + if ( state.backtracking==0 ) { + + retval.stypes = (else_clause141!=null?else_clause141.stypes:null); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1130:7: ELIF test[expr_contextType.Load] COLON suite[false] (e2= elif_clause | ) + { + root_0 = (PythonTree)adaptor.nil(); + + ELIF142=(Token)match(input,ELIF,FOLLOW_ELIF_in_elif_clause3627); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ELIF142_tree = (PythonTree)adaptor.create(ELIF142); + adaptor.addChild(root_0, ELIF142_tree); + } + pushFollow(FOLLOW_test_in_elif_clause3629); + test143=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test143.getTree()); + COLON144=(Token)match(input,COLON,FOLLOW_COLON_in_elif_clause3632); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON144_tree = (PythonTree)adaptor.create(COLON144); + adaptor.addChild(root_0, COLON144_tree); + } + pushFollow(FOLLOW_suite_in_elif_clause3634); + suite145=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, suite145.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1131:7: (e2= elif_clause | ) + int alt66=2; + int LA66_0 = input.LA(1); + + if ( (LA66_0==ELIF||LA66_0==ORELSE) ) { + alt66=1; + } + else if ( (LA66_0==EOF||LA66_0==DEDENT||LA66_0==NEWLINE||LA66_0==NAME||LA66_0==PRINT||(LA66_0>=ASSERT && LA66_0<=DELETE)||LA66_0==EXEC||(LA66_0>=FROM && LA66_0<=IMPORT)||(LA66_0>=LAMBDA && LA66_0<=NOT)||(LA66_0>=PASS && LA66_0<=LPAREN)||(LA66_0>=PLUS && LA66_0<=MINUS)||(LA66_0>=TILDE && LA66_0<=LBRACK)||LA66_0==LCURLY||(LA66_0>=BACKQUOTE && LA66_0<=STRING)) ) { + alt66=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 66, 0, input); + + throw nvae; + } + switch (alt66) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1131:8: e2= elif_clause + { + pushFollow(FOLLOW_elif_clause_in_elif_clause3646); + e2=elif_clause(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e2.getTree()); + if ( state.backtracking==0 ) { + + stype = new If((test143!=null?((Token)test143.start):null), actions.castExpr((test143!=null?((PythonTree)test143.tree):null)), actions.castStmts((suite145!=null?suite145.stypes:null)), actions.makeElse((e2!=null?e2.stypes:null), (e2!=null?((PythonTree)e2.tree):null))); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1136:8: + { + if ( state.backtracking==0 ) { + + stype = new If((test143!=null?((Token)test143.start):null), actions.castExpr((test143!=null?((PythonTree)test143.tree):null)), actions.castStmts((suite145!=null?suite145.stypes:null)), new ArrayList()); + + } + + } + break; + + } + + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (stype != null) { + retval.tree = stype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "elif_clause" + + public static class else_clause_return extends ParserRuleReturnScope { + public List stypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "else_clause" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1143:1: else_clause returns [List stypes] : ORELSE COLON elsesuite= suite[false] ; + public final PythonParser.else_clause_return else_clause() throws RecognitionException { + PythonParser.else_clause_return retval = new PythonParser.else_clause_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token ORELSE146=null; + Token COLON147=null; + PythonParser.suite_return elsesuite = null; + + + PythonTree ORELSE146_tree=null; + PythonTree COLON147_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1145:5: ( ORELSE COLON elsesuite= suite[false] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1145:7: ORELSE COLON elsesuite= suite[false] + { + root_0 = (PythonTree)adaptor.nil(); + + ORELSE146=(Token)match(input,ORELSE,FOLLOW_ORELSE_in_else_clause3706); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ORELSE146_tree = (PythonTree)adaptor.create(ORELSE146); + adaptor.addChild(root_0, ORELSE146_tree); + } + COLON147=(Token)match(input,COLON,FOLLOW_COLON_in_else_clause3708); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON147_tree = (PythonTree)adaptor.create(COLON147); + adaptor.addChild(root_0, COLON147_tree); + } + pushFollow(FOLLOW_suite_in_else_clause3712); + elsesuite=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, elsesuite.getTree()); + if ( state.backtracking==0 ) { + + retval.stypes = (elsesuite!=null?elsesuite.stypes:null); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "else_clause" + + public static class while_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "while_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1152:1: while_stmt : WHILE test[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? ; + public final PythonParser.while_stmt_return while_stmt() throws RecognitionException { + PythonParser.while_stmt_return retval = new PythonParser.while_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token WHILE148=null; + Token COLON150=null; + Token ORELSE151=null; + Token COLON152=null; + PythonParser.suite_return s1 = null; + + PythonParser.suite_return s2 = null; + + PythonParser.test_return test149 = null; + + + PythonTree WHILE148_tree=null; + PythonTree COLON150_tree=null; + PythonTree ORELSE151_tree=null; + PythonTree COLON152_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1159:5: ( WHILE test[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1159:7: WHILE test[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? + { + root_0 = (PythonTree)adaptor.nil(); + + WHILE148=(Token)match(input,WHILE,FOLLOW_WHILE_in_while_stmt3749); if (state.failed) return retval; + if ( state.backtracking==0 ) { + WHILE148_tree = (PythonTree)adaptor.create(WHILE148); + adaptor.addChild(root_0, WHILE148_tree); + } + pushFollow(FOLLOW_test_in_while_stmt3751); + test149=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test149.getTree()); + COLON150=(Token)match(input,COLON,FOLLOW_COLON_in_while_stmt3754); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON150_tree = (PythonTree)adaptor.create(COLON150); + adaptor.addChild(root_0, COLON150_tree); + } + pushFollow(FOLLOW_suite_in_while_stmt3758); + s1=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1159:63: ( ORELSE COLON s2= suite[false] )? + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==ORELSE) ) { + alt68=1; + } + switch (alt68) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1159:64: ORELSE COLON s2= suite[false] + { + ORELSE151=(Token)match(input,ORELSE,FOLLOW_ORELSE_in_while_stmt3762); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ORELSE151_tree = (PythonTree)adaptor.create(ORELSE151); + adaptor.addChild(root_0, ORELSE151_tree); + } + COLON152=(Token)match(input,COLON,FOLLOW_COLON_in_while_stmt3764); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON152_tree = (PythonTree)adaptor.create(COLON152); + adaptor.addChild(root_0, COLON152_tree); + } + pushFollow(FOLLOW_suite_in_while_stmt3768); + s2=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s2.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = actions.makeWhile(WHILE148, actions.castExpr((test149!=null?((PythonTree)test149.tree):null)), (s1!=null?s1.stypes:null), (s2!=null?s2.stypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "while_stmt" + + public static class for_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "for_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1166:1: for_stmt : FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? ; + public final PythonParser.for_stmt_return for_stmt() throws RecognitionException { + PythonParser.for_stmt_return retval = new PythonParser.for_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token FOR153=null; + Token IN155=null; + Token COLON157=null; + Token ORELSE158=null; + Token COLON159=null; + PythonParser.suite_return s1 = null; + + PythonParser.suite_return s2 = null; + + PythonParser.exprlist_return exprlist154 = null; + + PythonParser.testlist_return testlist156 = null; + + + PythonTree FOR153_tree=null; + PythonTree IN155_tree=null; + PythonTree COLON157_tree=null; + PythonTree ORELSE158_tree=null; + PythonTree COLON159_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1173:5: ( FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1173:7: FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] COLON s1= suite[false] ( ORELSE COLON s2= suite[false] )? + { + root_0 = (PythonTree)adaptor.nil(); + + FOR153=(Token)match(input,FOR,FOLLOW_FOR_in_for_stmt3807); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FOR153_tree = (PythonTree)adaptor.create(FOR153); + adaptor.addChild(root_0, FOR153_tree); + } + pushFollow(FOLLOW_exprlist_in_for_stmt3809); + exprlist154=exprlist(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, exprlist154.getTree()); + IN155=(Token)match(input,IN,FOLLOW_IN_in_for_stmt3812); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN155_tree = (PythonTree)adaptor.create(IN155); + adaptor.addChild(root_0, IN155_tree); + } + pushFollow(FOLLOW_testlist_in_for_stmt3814); + testlist156=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist156.getTree()); + COLON157=(Token)match(input,COLON,FOLLOW_COLON_in_for_stmt3817); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON157_tree = (PythonTree)adaptor.create(COLON157); + adaptor.addChild(root_0, COLON157_tree); + } + pushFollow(FOLLOW_suite_in_for_stmt3821); + s1=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1174:9: ( ORELSE COLON s2= suite[false] )? + int alt69=2; + int LA69_0 = input.LA(1); + + if ( (LA69_0==ORELSE) ) { + alt69=1; + } + switch (alt69) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1174:10: ORELSE COLON s2= suite[false] + { + ORELSE158=(Token)match(input,ORELSE,FOLLOW_ORELSE_in_for_stmt3833); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ORELSE158_tree = (PythonTree)adaptor.create(ORELSE158); + adaptor.addChild(root_0, ORELSE158_tree); + } + COLON159=(Token)match(input,COLON,FOLLOW_COLON_in_for_stmt3835); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON159_tree = (PythonTree)adaptor.create(COLON159); + adaptor.addChild(root_0, COLON159_tree); + } + pushFollow(FOLLOW_suite_in_for_stmt3839); + s2=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s2.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = actions.makeFor(FOR153, (exprlist154!=null?exprlist154.etype:null), actions.castExpr((testlist156!=null?((PythonTree)testlist156.tree):null)), (s1!=null?s1.stypes:null), (s2!=null?s2.stypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "for_stmt" + + public static class try_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "try_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1185:1: try_stmt : TRY COLON trysuite= suite[!$suite.isEmpty() && $suite::continueIllegal] ( (e+= except_clause )+ ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? ( FINALLY COLON finalsuite= suite[true] )? | FINALLY COLON finalsuite= suite[true] ) ; + public final PythonParser.try_stmt_return try_stmt() throws RecognitionException { + PythonParser.try_stmt_return retval = new PythonParser.try_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token TRY160=null; + Token COLON161=null; + Token ORELSE162=null; + Token COLON163=null; + Token FINALLY164=null; + Token COLON165=null; + Token FINALLY166=null; + Token COLON167=null; + List list_e=null; + PythonParser.suite_return trysuite = null; + + PythonParser.suite_return elsesuite = null; + + PythonParser.suite_return finalsuite = null; + + PythonParser.except_clause_return e = null; + e = null; + PythonTree TRY160_tree=null; + PythonTree COLON161_tree=null; + PythonTree ORELSE162_tree=null; + PythonTree COLON163_tree=null; + PythonTree FINALLY164_tree=null; + PythonTree COLON165_tree=null; + PythonTree FINALLY166_tree=null; + PythonTree COLON167_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1192:5: ( TRY COLON trysuite= suite[!$suite.isEmpty() && $suite::continueIllegal] ( (e+= except_clause )+ ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? ( FINALLY COLON finalsuite= suite[true] )? | FINALLY COLON finalsuite= suite[true] ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1192:7: TRY COLON trysuite= suite[!$suite.isEmpty() && $suite::continueIllegal] ( (e+= except_clause )+ ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? ( FINALLY COLON finalsuite= suite[true] )? | FINALLY COLON finalsuite= suite[true] ) + { + root_0 = (PythonTree)adaptor.nil(); + + TRY160=(Token)match(input,TRY,FOLLOW_TRY_in_try_stmt3882); if (state.failed) return retval; + if ( state.backtracking==0 ) { + TRY160_tree = (PythonTree)adaptor.create(TRY160); + adaptor.addChild(root_0, TRY160_tree); + } + COLON161=(Token)match(input,COLON,FOLLOW_COLON_in_try_stmt3884); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON161_tree = (PythonTree)adaptor.create(COLON161); + adaptor.addChild(root_0, COLON161_tree); + } + pushFollow(FOLLOW_suite_in_try_stmt3888); + trysuite=suite(!suite_stack.isEmpty() && ((suite_scope)suite_stack.peek()).continueIllegal); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, trysuite.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:7: ( (e+= except_clause )+ ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? ( FINALLY COLON finalsuite= suite[true] )? | FINALLY COLON finalsuite= suite[true] ) + int alt73=2; + int LA73_0 = input.LA(1); + + if ( (LA73_0==EXCEPT) ) { + alt73=1; + } + else if ( (LA73_0==FINALLY) ) { + alt73=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 73, 0, input); + + throw nvae; + } + switch (alt73) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:9: (e+= except_clause )+ ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? ( FINALLY COLON finalsuite= suite[true] )? + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:10: (e+= except_clause )+ + int cnt70=0; + loop70: + do { + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==EXCEPT) ) { + alt70=1; + } + + + switch (alt70) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:10: e+= except_clause + { + pushFollow(FOLLOW_except_clause_in_try_stmt3901); + e=except_clause(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree()); + if (list_e==null) list_e=new ArrayList(); + list_e.add(e.getTree()); + + + } + break; + + default : + if ( cnt70 >= 1 ) break loop70; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(70, input); + throw eee; + } + cnt70++; + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:27: ( ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] )? + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==ORELSE) ) { + alt71=1; + } + switch (alt71) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:28: ORELSE COLON elsesuite= suite[!$suite.isEmpty() && $suite::continueIllegal] + { + ORELSE162=(Token)match(input,ORELSE,FOLLOW_ORELSE_in_try_stmt3905); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ORELSE162_tree = (PythonTree)adaptor.create(ORELSE162); + adaptor.addChild(root_0, ORELSE162_tree); + } + COLON163=(Token)match(input,COLON,FOLLOW_COLON_in_try_stmt3907); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON163_tree = (PythonTree)adaptor.create(COLON163); + adaptor.addChild(root_0, COLON163_tree); + } + pushFollow(FOLLOW_suite_in_try_stmt3911); + elsesuite=suite(!suite_stack.isEmpty() && ((suite_scope)suite_stack.peek()).continueIllegal); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, elsesuite.getTree()); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:105: ( FINALLY COLON finalsuite= suite[true] )? + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==FINALLY) ) { + alt72=1; + } + switch (alt72) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1193:106: FINALLY COLON finalsuite= suite[true] + { + FINALLY164=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_try_stmt3917); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FINALLY164_tree = (PythonTree)adaptor.create(FINALLY164); + adaptor.addChild(root_0, FINALLY164_tree); + } + COLON165=(Token)match(input,COLON,FOLLOW_COLON_in_try_stmt3919); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON165_tree = (PythonTree)adaptor.create(COLON165); + adaptor.addChild(root_0, COLON165_tree); + } + pushFollow(FOLLOW_suite_in_try_stmt3923); + finalsuite=suite(true); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, finalsuite.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + stype = actions.makeTryExcept(TRY160, (trysuite!=null?trysuite.stypes:null), list_e, (elsesuite!=null?elsesuite.stypes:null), (finalsuite!=null?finalsuite.stypes:null)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1197:9: FINALLY COLON finalsuite= suite[true] + { + FINALLY166=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_try_stmt3946); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FINALLY166_tree = (PythonTree)adaptor.create(FINALLY166); + adaptor.addChild(root_0, FINALLY166_tree); + } + COLON167=(Token)match(input,COLON,FOLLOW_COLON_in_try_stmt3948); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON167_tree = (PythonTree)adaptor.create(COLON167); + adaptor.addChild(root_0, COLON167_tree); + } + pushFollow(FOLLOW_suite_in_try_stmt3952); + finalsuite=suite(true); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, finalsuite.getTree()); + if ( state.backtracking==0 ) { + + stype = actions.makeTryFinally(TRY160, (trysuite!=null?trysuite.stypes:null), (finalsuite!=null?finalsuite.stypes:null)); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "try_stmt" + + public static class with_stmt_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "with_stmt" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1205:1: with_stmt : WITH w+= with_item ( options {greedy=true; } : COMMA w+= with_item )* COLON suite[false] ; + public final PythonParser.with_stmt_return with_stmt() throws RecognitionException { + PythonParser.with_stmt_return retval = new PythonParser.with_stmt_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token WITH168=null; + Token COMMA169=null; + Token COLON170=null; + List list_w=null; + PythonParser.suite_return suite171 = null; + + PythonParser.with_item_return w = null; + w = null; + PythonTree WITH168_tree=null; + PythonTree COMMA169_tree=null; + PythonTree COLON170_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1212:5: ( WITH w+= with_item ( options {greedy=true; } : COMMA w+= with_item )* COLON suite[false] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1212:7: WITH w+= with_item ( options {greedy=true; } : COMMA w+= with_item )* COLON suite[false] + { + root_0 = (PythonTree)adaptor.nil(); + + WITH168=(Token)match(input,WITH,FOLLOW_WITH_in_with_stmt4001); if (state.failed) return retval; + if ( state.backtracking==0 ) { + WITH168_tree = (PythonTree)adaptor.create(WITH168); + adaptor.addChild(root_0, WITH168_tree); + } + pushFollow(FOLLOW_with_item_in_with_stmt4005); + w=with_item(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, w.getTree()); + if (list_w==null) list_w=new ArrayList(); + list_w.add(w.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1212:25: ( options {greedy=true; } : COMMA w+= with_item )* + loop74: + do { + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==COMMA) ) { + alt74=1; + } + + + switch (alt74) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1212:49: COMMA w+= with_item + { + COMMA169=(Token)match(input,COMMA,FOLLOW_COMMA_in_with_stmt4015); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA169_tree = (PythonTree)adaptor.create(COMMA169); + adaptor.addChild(root_0, COMMA169_tree); + } + pushFollow(FOLLOW_with_item_in_with_stmt4019); + w=with_item(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, w.getTree()); + if (list_w==null) list_w=new ArrayList(); + list_w.add(w.getTree()); + + + } + break; + + default : + break loop74; + } + } while (true); + + COLON170=(Token)match(input,COLON,FOLLOW_COLON_in_with_stmt4023); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON170_tree = (PythonTree)adaptor.create(COLON170); + adaptor.addChild(root_0, COLON170_tree); + } + pushFollow(FOLLOW_suite_in_with_stmt4025); + suite171=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, suite171.getTree()); + if ( state.backtracking==0 ) { + + stype = actions.makeWith(WITH168, list_w, (suite171!=null?suite171.stypes:null)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "with_stmt" + + public static class with_item_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "with_item" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1219:1: with_item : test[expr_contextType.Load] ( AS expr[expr_contextType.Store] )? ; + public final PythonParser.with_item_return with_item() throws RecognitionException { + PythonParser.with_item_return retval = new PythonParser.with_item_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token AS173=null; + PythonParser.test_return test172 = null; + + PythonParser.expr_return expr174 = null; + + + PythonTree AS173_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1226:5: ( test[expr_contextType.Load] ( AS expr[expr_contextType.Store] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1226:7: test[expr_contextType.Load] ( AS expr[expr_contextType.Store] )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_with_item4062); + test172=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test172.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1226:35: ( AS expr[expr_contextType.Store] )? + int alt75=2; + int LA75_0 = input.LA(1); + + if ( (LA75_0==AS) ) { + alt75=1; + } + switch (alt75) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1226:36: AS expr[expr_contextType.Store] + { + AS173=(Token)match(input,AS,FOLLOW_AS_in_with_item4066); if (state.failed) return retval; + if ( state.backtracking==0 ) { + AS173_tree = (PythonTree)adaptor.create(AS173); + adaptor.addChild(root_0, AS173_tree); + } + pushFollow(FOLLOW_expr_in_with_item4068); + expr174=expr(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, expr174.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + expr item = actions.castExpr((test172!=null?((PythonTree)test172.tree):null)); + expr var = null; + if ((expr174!=null?((Token)expr174.start):null) != null) { + var = actions.castExpr((expr174!=null?((PythonTree)expr174.tree):null)); + actions.checkAssign(var); + } + stype = new With((test172!=null?((Token)test172.start):null), item, var, null); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "with_item" + + public static class except_clause_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "except_clause" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1239:1: except_clause : EXCEPT (t1= test[expr_contextType.Load] ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? )? COLON suite[!$suite.isEmpty() && $suite::continueIllegal] ; + public final PythonParser.except_clause_return except_clause() throws RecognitionException { + PythonParser.except_clause_return retval = new PythonParser.except_clause_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token EXCEPT175=null; + Token set176=null; + Token COLON177=null; + PythonParser.test_return t1 = null; + + PythonParser.test_return t2 = null; + + PythonParser.suite_return suite178 = null; + + + PythonTree EXCEPT175_tree=null; + PythonTree set176_tree=null; + PythonTree COLON177_tree=null; + + + excepthandler extype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:5: ( EXCEPT (t1= test[expr_contextType.Load] ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? )? COLON suite[!$suite.isEmpty() && $suite::continueIllegal] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:7: EXCEPT (t1= test[expr_contextType.Load] ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? )? COLON suite[!$suite.isEmpty() && $suite::continueIllegal] + { + root_0 = (PythonTree)adaptor.nil(); + + EXCEPT175=(Token)match(input,EXCEPT,FOLLOW_EXCEPT_in_except_clause4107); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EXCEPT175_tree = (PythonTree)adaptor.create(EXCEPT175); + adaptor.addChild(root_0, EXCEPT175_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:14: (t1= test[expr_contextType.Load] ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? )? + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==NAME||LA77_0==NOT||LA77_0==LPAREN||(LA77_0>=PLUS && LA77_0<=MINUS)||(LA77_0>=TILDE && LA77_0<=LBRACK)||LA77_0==LCURLY||LA77_0==BACKQUOTE) ) { + alt77=1; + } + else if ( (LA77_0==PRINT) && ((printFunction))) { + alt77=1; + } + else if ( (LA77_0==LAMBDA||(LA77_0>=INT && LA77_0<=STRING)) ) { + alt77=1; + } + switch (alt77) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:15: t1= test[expr_contextType.Load] ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? + { + pushFollow(FOLLOW_test_in_except_clause4112); + t1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:46: ( ( COMMA | AS ) t2= test[expr_contextType.Store] )? + int alt76=2; + int LA76_0 = input.LA(1); + + if ( (LA76_0==AS||LA76_0==COMMA) ) { + alt76=1; + } + switch (alt76) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1246:47: ( COMMA | AS ) t2= test[expr_contextType.Store] + { + set176=(Token)input.LT(1); + if ( input.LA(1)==AS||input.LA(1)==COMMA ) { + input.consume(); + if ( state.backtracking==0 ) adaptor.addChild(root_0, (PythonTree)adaptor.create(set176)); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + pushFollow(FOLLOW_test_in_except_clause4126); + t2=test(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + + } + break; + + } + + + } + break; + + } + + COLON177=(Token)match(input,COLON,FOLLOW_COLON_in_except_clause4133); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON177_tree = (PythonTree)adaptor.create(COLON177); + adaptor.addChild(root_0, COLON177_tree); + } + pushFollow(FOLLOW_suite_in_except_clause4135); + suite178=suite(!suite_stack.isEmpty() && ((suite_scope)suite_stack.peek()).continueIllegal); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, suite178.getTree()); + if ( state.backtracking==0 ) { + + extype = new ExceptHandler(EXCEPT175, actions.castExpr((t1!=null?((PythonTree)t1.tree):null)), actions.castExpr((t2!=null?((PythonTree)t2.tree):null)), + actions.castStmts((suite178!=null?suite178.stypes:null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = extype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "except_clause" + + protected static class suite_scope { + boolean continueIllegal; + } + protected Stack suite_stack = new Stack(); + + public static class suite_return extends ParserRuleReturnScope { + public List stypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "suite" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1254:1: suite[boolean fromFinally] returns [List stypes] : ( simple_stmt | NEWLINE INDENT ( stmt )+ DEDENT ); + public final PythonParser.suite_return suite(boolean fromFinally) throws RecognitionException { + suite_stack.push(new suite_scope()); + PythonParser.suite_return retval = new PythonParser.suite_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NEWLINE180=null; + Token INDENT181=null; + Token DEDENT183=null; + PythonParser.simple_stmt_return simple_stmt179 = null; + + PythonParser.stmt_return stmt182 = null; + + + PythonTree NEWLINE180_tree=null; + PythonTree INDENT181_tree=null; + PythonTree DEDENT183_tree=null; + + + if (((suite_scope)suite_stack.peek()).continueIllegal || fromFinally) { + ((suite_scope)suite_stack.peek()).continueIllegal = true; + } else { + ((suite_scope)suite_stack.peek()).continueIllegal = false; + } + retval.stypes = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1267:5: ( simple_stmt | NEWLINE INDENT ( stmt )+ DEDENT ) + int alt79=2; + int LA79_0 = input.LA(1); + + if ( (LA79_0==NAME||LA79_0==NOT||LA79_0==LPAREN||(LA79_0>=PLUS && LA79_0<=MINUS)||(LA79_0>=TILDE && LA79_0<=LBRACK)||LA79_0==LCURLY||LA79_0==BACKQUOTE) ) { + alt79=1; + } + else if ( (LA79_0==PRINT) && (((printFunction)||(!printFunction)))) { + alt79=1; + } + else if ( ((LA79_0>=ASSERT && LA79_0<=BREAK)||LA79_0==CONTINUE||LA79_0==DELETE||LA79_0==EXEC||LA79_0==FROM||LA79_0==GLOBAL||LA79_0==IMPORT||LA79_0==LAMBDA||(LA79_0>=PASS && LA79_0<=RETURN)||LA79_0==YIELD||(LA79_0>=INT && LA79_0<=STRING)) ) { + alt79=1; + } + else if ( (LA79_0==NEWLINE) ) { + alt79=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 79, 0, input); + + throw nvae; + } + switch (alt79) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1267:7: simple_stmt + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_simple_stmt_in_suite4181); + simple_stmt179=simple_stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_stmt179.getTree()); + if ( state.backtracking==0 ) { + + retval.stypes = (simple_stmt179!=null?simple_stmt179.stypes:null); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1271:7: NEWLINE INDENT ( stmt )+ DEDENT + { + root_0 = (PythonTree)adaptor.nil(); + + NEWLINE180=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_suite4197); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NEWLINE180_tree = (PythonTree)adaptor.create(NEWLINE180); + adaptor.addChild(root_0, NEWLINE180_tree); + } + INDENT181=(Token)match(input,INDENT,FOLLOW_INDENT_in_suite4199); if (state.failed) return retval; + if ( state.backtracking==0 ) { + INDENT181_tree = (PythonTree)adaptor.create(INDENT181); + adaptor.addChild(root_0, INDENT181_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1272:7: ( stmt )+ + int cnt78=0; + loop78: + do { + int alt78=2; + int LA78_0 = input.LA(1); + + if ( (LA78_0==NAME||LA78_0==NOT||LA78_0==LPAREN||(LA78_0>=PLUS && LA78_0<=MINUS)||(LA78_0>=TILDE && LA78_0<=LBRACK)||LA78_0==LCURLY||LA78_0==BACKQUOTE) ) { + alt78=1; + } + else if ( (LA78_0==PRINT) && (((printFunction)||(!printFunction)))) { + alt78=1; + } + else if ( ((LA78_0>=ASSERT && LA78_0<=DELETE)||LA78_0==EXEC||(LA78_0>=FROM && LA78_0<=IMPORT)||LA78_0==LAMBDA||(LA78_0>=PASS && LA78_0<=AT)||(LA78_0>=INT && LA78_0<=STRING)) ) { + alt78=1; + } + + + switch (alt78) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1272:8: stmt + { + pushFollow(FOLLOW_stmt_in_suite4208); + stmt182=stmt(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, stmt182.getTree()); + if ( state.backtracking==0 ) { + + if ((stmt182!=null?stmt182.stypes:null) != null) { + retval.stypes.addAll((stmt182!=null?stmt182.stypes:null)); + } + + } + + } + break; + + default : + if ( cnt78 >= 1 ) break loop78; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(78, input); + throw eee; + } + cnt78++; + } while (true); + + DEDENT183=(Token)match(input,DEDENT,FOLLOW_DEDENT_in_suite4228); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DEDENT183_tree = (PythonTree)adaptor.create(DEDENT183); + adaptor.addChild(root_0, DEDENT183_tree); + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + suite_stack.pop(); + } + return retval; + } + // $ANTLR end "suite" + + public static class test_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "test" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1282:1: test[expr_contextType ctype] : (o1= or_test[ctype] ( ( IF or_test[null] ORELSE )=> IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] | -> or_test ) | lambdef ); + public final PythonParser.test_return test(expr_contextType ctype) throws RecognitionException { + PythonParser.test_return retval = new PythonParser.test_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token IF184=null; + Token ORELSE185=null; + PythonParser.or_test_return o1 = null; + + PythonParser.or_test_return o2 = null; + + PythonParser.test_return e = null; + + PythonParser.lambdef_return lambdef186 = null; + + + PythonTree IF184_tree=null; + PythonTree ORELSE185_tree=null; + RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF"); + RewriteRuleTokenStream stream_ORELSE=new RewriteRuleTokenStream(adaptor,"token ORELSE"); + RewriteRuleSubtreeStream stream_or_test=new RewriteRuleSubtreeStream(adaptor,"rule or_test"); + RewriteRuleSubtreeStream stream_test=new RewriteRuleSubtreeStream(adaptor,"rule test"); + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1291:5: (o1= or_test[ctype] ( ( IF or_test[null] ORELSE )=> IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] | -> or_test ) | lambdef ) + int alt81=2; + int LA81_0 = input.LA(1); + + if ( (LA81_0==NAME||LA81_0==NOT||LA81_0==LPAREN||(LA81_0>=PLUS && LA81_0<=MINUS)||(LA81_0>=TILDE && LA81_0<=LBRACK)||LA81_0==LCURLY||LA81_0==BACKQUOTE) ) { + alt81=1; + } + else if ( (LA81_0==PRINT) && ((printFunction))) { + alt81=1; + } + else if ( ((LA81_0>=INT && LA81_0<=STRING)) ) { + alt81=1; + } + else if ( (LA81_0==LAMBDA) ) { + alt81=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 81, 0, input); + + throw nvae; + } + switch (alt81) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1291:6: o1= or_test[ctype] ( ( IF or_test[null] ORELSE )=> IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] | -> or_test ) + { + pushFollow(FOLLOW_or_test_in_test4258); + o1=or_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_or_test.add(o1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1292:7: ( ( IF or_test[null] ORELSE )=> IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] | -> or_test ) + int alt80=2; + alt80 = dfa80.predict(input); + switch (alt80) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1292:9: ( IF or_test[null] ORELSE )=> IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] + { + IF184=(Token)match(input,IF,FOLLOW_IF_in_test4280); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_IF.add(IF184); + + pushFollow(FOLLOW_or_test_in_test4284); + o2=or_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_or_test.add(o2.getTree()); + ORELSE185=(Token)match(input,ORELSE,FOLLOW_ORELSE_in_test4287); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_ORELSE.add(ORELSE185); + + pushFollow(FOLLOW_test_in_test4291); + e=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_test.add(e.getTree()); + if ( state.backtracking==0 ) { + + etype = new IfExp((o1!=null?((Token)o1.start):null), actions.castExpr((o2!=null?((PythonTree)o2.tree):null)), actions.castExpr((o1!=null?((PythonTree)o1.tree):null)), actions.castExpr((e!=null?((PythonTree)e.tree):null))); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1297:6: + { + + // AST REWRITE + // elements: or_test + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1297:6: -> or_test + { + adaptor.addChild(root_0, stream_or_test.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1299:7: lambdef + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_lambdef_in_test4336); + lambdef186=lambdef(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, lambdef186.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "test" + + public static class or_test_return extends ParserRuleReturnScope { + public Token leftTok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "or_test" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1303:1: or_test[expr_contextType ctype] returns [Token leftTok] : left= and_test[ctype] ( (or= OR right+= and_test[ctype] )+ | -> $left) ; + public final PythonParser.or_test_return or_test(expr_contextType ctype) throws RecognitionException { + PythonParser.or_test_return retval = new PythonParser.or_test_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token or=null; + List list_right=null; + PythonParser.and_test_return left = null; + + PythonParser.and_test_return right = null; + right = null; + PythonTree or_tree=null; + RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR"); + RewriteRuleSubtreeStream stream_and_test=new RewriteRuleSubtreeStream(adaptor,"rule and_test"); + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1314:5: (left= and_test[ctype] ( (or= OR right+= and_test[ctype] )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1314:7: left= and_test[ctype] ( (or= OR right+= and_test[ctype] )+ | -> $left) + { + pushFollow(FOLLOW_and_test_in_or_test4371); + left=and_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_and_test.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1315:9: ( (or= OR right+= and_test[ctype] )+ | -> $left) + int alt83=2; + int LA83_0 = input.LA(1); + + if ( (LA83_0==OR) ) { + alt83=1; + } + else if ( (LA83_0==EOF||LA83_0==NEWLINE||LA83_0==AS||LA83_0==FOR||LA83_0==IF||LA83_0==ORELSE||(LA83_0>=RPAREN && LA83_0<=COMMA)||(LA83_0>=SEMI && LA83_0<=DOUBLESLASHEQUAL)||LA83_0==RBRACK||(LA83_0>=RCURLY && LA83_0<=BACKQUOTE)) ) { + alt83=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 83, 0, input); + + throw nvae; + } + switch (alt83) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1315:11: (or= OR right+= and_test[ctype] )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1315:11: (or= OR right+= and_test[ctype] )+ + int cnt82=0; + loop82: + do { + int alt82=2; + int LA82_0 = input.LA(1); + + if ( (LA82_0==OR) ) { + alt82=1; + } + + + switch (alt82) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1315:12: or= OR right+= and_test[ctype] + { + or=(Token)match(input,OR,FOLLOW_OR_in_or_test4387); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_OR.add(or); + + pushFollow(FOLLOW_and_test_in_or_test4391); + right=and_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_and_test.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + + } + break; + + default : + if ( cnt82 >= 1 ) break loop82; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(82, input); + throw eee; + } + cnt82++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1318:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1318:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (or != null) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.leftTok:null) != null) { + tok = (left!=null?left.leftTok:null); + } + retval.tree = actions.makeBoolOp(tok, (left!=null?((PythonTree)left.tree):null), boolopType.Or, list_right); + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "or_test" + + public static class and_test_return extends ParserRuleReturnScope { + public Token leftTok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "and_test" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1323:1: and_test[expr_contextType ctype] returns [Token leftTok] : left= not_test[ctype] ( (and= AND right+= not_test[ctype] )+ | -> $left) ; + public final PythonParser.and_test_return and_test(expr_contextType ctype) throws RecognitionException { + PythonParser.and_test_return retval = new PythonParser.and_test_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token and=null; + List list_right=null; + PythonParser.not_test_return left = null; + + PythonParser.not_test_return right = null; + right = null; + PythonTree and_tree=null; + RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND"); + RewriteRuleSubtreeStream stream_not_test=new RewriteRuleSubtreeStream(adaptor,"rule not_test"); + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1334:5: (left= not_test[ctype] ( (and= AND right+= not_test[ctype] )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1334:7: left= not_test[ctype] ( (and= AND right+= not_test[ctype] )+ | -> $left) + { + pushFollow(FOLLOW_not_test_in_and_test4472); + left=not_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_not_test.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1335:9: ( (and= AND right+= not_test[ctype] )+ | -> $left) + int alt85=2; + int LA85_0 = input.LA(1); + + if ( (LA85_0==AND) ) { + alt85=1; + } + else if ( (LA85_0==EOF||LA85_0==NEWLINE||LA85_0==AS||LA85_0==FOR||LA85_0==IF||(LA85_0>=OR && LA85_0<=ORELSE)||(LA85_0>=RPAREN && LA85_0<=COMMA)||(LA85_0>=SEMI && LA85_0<=DOUBLESLASHEQUAL)||LA85_0==RBRACK||(LA85_0>=RCURLY && LA85_0<=BACKQUOTE)) ) { + alt85=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 85, 0, input); + + throw nvae; + } + switch (alt85) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1335:11: (and= AND right+= not_test[ctype] )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1335:11: (and= AND right+= not_test[ctype] )+ + int cnt84=0; + loop84: + do { + int alt84=2; + int LA84_0 = input.LA(1); + + if ( (LA84_0==AND) ) { + alt84=1; + } + + + switch (alt84) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1335:12: and= AND right+= not_test[ctype] + { + and=(Token)match(input,AND,FOLLOW_AND_in_and_test4488); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_AND.add(and); + + pushFollow(FOLLOW_not_test_in_and_test4492); + right=not_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_not_test.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + + } + break; + + default : + if ( cnt84 >= 1 ) break loop84; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(84, input); + throw eee; + } + cnt84++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1338:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1338:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (and != null) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.leftTok:null) != null) { + tok = (left!=null?left.leftTok:null); + } + retval.tree = actions.makeBoolOp(tok, (left!=null?((PythonTree)left.tree):null), boolopType.And, list_right); + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "and_test" + + public static class not_test_return extends ParserRuleReturnScope { + public Token leftTok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "not_test" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1343:1: not_test[expr_contextType ctype] returns [Token leftTok] : ( NOT nt= not_test[ctype] | comparison[ctype] ); + public final PythonParser.not_test_return not_test(expr_contextType ctype) throws RecognitionException { + PythonParser.not_test_return retval = new PythonParser.not_test_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token NOT187=null; + PythonParser.not_test_return nt = null; + + PythonParser.comparison_return comparison188 = null; + + + PythonTree NOT187_tree=null; + + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1353:5: ( NOT nt= not_test[ctype] | comparison[ctype] ) + int alt86=2; + int LA86_0 = input.LA(1); + + if ( (LA86_0==NOT) ) { + alt86=1; + } + else if ( (LA86_0==NAME||LA86_0==LPAREN||(LA86_0>=PLUS && LA86_0<=MINUS)||(LA86_0>=TILDE && LA86_0<=LBRACK)||LA86_0==LCURLY||LA86_0==BACKQUOTE) ) { + alt86=2; + } + else if ( (LA86_0==PRINT) && ((printFunction))) { + alt86=2; + } + else if ( ((LA86_0>=INT && LA86_0<=STRING)) ) { + alt86=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 86, 0, input); + + throw nvae; + } + switch (alt86) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1353:7: NOT nt= not_test[ctype] + { + root_0 = (PythonTree)adaptor.nil(); + + NOT187=(Token)match(input,NOT,FOLLOW_NOT_in_not_test4576); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NOT187_tree = (PythonTree)adaptor.create(NOT187); + adaptor.addChild(root_0, NOT187_tree); + } + pushFollow(FOLLOW_not_test_in_not_test4580); + nt=not_test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, nt.getTree()); + if ( state.backtracking==0 ) { + + etype = new UnaryOp(NOT187, unaryopType.Not, actions.castExpr((nt!=null?((PythonTree)nt.tree):null))); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1357:7: comparison[ctype] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_comparison_in_not_test4597); + comparison188=comparison(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comparison188.getTree()); + if ( state.backtracking==0 ) { + + retval.leftTok = (comparison188!=null?comparison188.leftTok:null); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "not_test" + + public static class comparison_return extends ParserRuleReturnScope { + public Token leftTok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "comparison" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1364:1: comparison[expr_contextType ctype] returns [Token leftTok] : left= expr[ctype] ( ( comp_op right+= expr[ctype] )+ | -> $left) ; + public final PythonParser.comparison_return comparison(expr_contextType ctype) throws RecognitionException { + PythonParser.comparison_return retval = new PythonParser.comparison_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + List list_right=null; + PythonParser.expr_return left = null; + + PythonParser.comp_op_return comp_op189 = null; + + PythonParser.expr_return right = null; + right = null; + RewriteRuleSubtreeStream stream_comp_op=new RewriteRuleSubtreeStream(adaptor,"rule comp_op"); + RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); + + List cmps = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1376:5: (left= expr[ctype] ( ( comp_op right+= expr[ctype] )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1376:7: left= expr[ctype] ( ( comp_op right+= expr[ctype] )+ | -> $left) + { + pushFollow(FOLLOW_expr_in_comparison4646); + left=expr(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_expr.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1377:8: ( ( comp_op right+= expr[ctype] )+ | -> $left) + int alt88=2; + int LA88_0 = input.LA(1); + + if ( ((LA88_0>=IN && LA88_0<=IS)||LA88_0==NOT||(LA88_0>=LESS && LA88_0<=NOTEQUAL)) ) { + alt88=1; + } + else if ( (LA88_0==EOF||LA88_0==NEWLINE||(LA88_0>=AND && LA88_0<=AS)||LA88_0==FOR||LA88_0==IF||(LA88_0>=OR && LA88_0<=ORELSE)||(LA88_0>=RPAREN && LA88_0<=COMMA)||(LA88_0>=SEMI && LA88_0<=DOUBLESLASHEQUAL)||LA88_0==RBRACK||(LA88_0>=RCURLY && LA88_0<=BACKQUOTE)) ) { + alt88=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 88, 0, input); + + throw nvae; + } + switch (alt88) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1377:10: ( comp_op right+= expr[ctype] )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1377:10: ( comp_op right+= expr[ctype] )+ + int cnt87=0; + loop87: + do { + int alt87=2; + int LA87_0 = input.LA(1); + + if ( ((LA87_0>=IN && LA87_0<=IS)||LA87_0==NOT||(LA87_0>=LESS && LA87_0<=NOTEQUAL)) ) { + alt87=1; + } + + + switch (alt87) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1377:12: comp_op right+= expr[ctype] + { + pushFollow(FOLLOW_comp_op_in_comparison4660); + comp_op189=comp_op(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_comp_op.add(comp_op189.getTree()); + pushFollow(FOLLOW_expr_in_comparison4664); + right=expr(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_expr.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + if ( state.backtracking==0 ) { + + cmps.add((comp_op189!=null?comp_op189.op:null)); + + } + + } + break; + + default : + if ( cnt87 >= 1 ) break loop87; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(87, input); + throw eee; + } + cnt87++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1383:7: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1383:7: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.leftTok = (left!=null?left.leftTok:null); + if (!cmps.isEmpty()) { + retval.tree = new Compare((left!=null?((Token)left.start):null), actions.castExpr((left!=null?((PythonTree)left.tree):null)), actions.makeCmpOps(cmps), + actions.castExprs(list_right)); + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "comparison" + + public static class comp_op_return extends ParserRuleReturnScope { + public cmpopType op; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "comp_op" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1388:1: comp_op returns [cmpopType op] : ( LESS | GREATER | EQUAL | GREATEREQUAL | LESSEQUAL | ALT_NOTEQUAL | NOTEQUAL | IN | NOT IN | IS | IS NOT ); + public final PythonParser.comp_op_return comp_op() throws RecognitionException { + PythonParser.comp_op_return retval = new PythonParser.comp_op_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LESS190=null; + Token GREATER191=null; + Token EQUAL192=null; + Token GREATEREQUAL193=null; + Token LESSEQUAL194=null; + Token ALT_NOTEQUAL195=null; + Token NOTEQUAL196=null; + Token IN197=null; + Token NOT198=null; + Token IN199=null; + Token IS200=null; + Token IS201=null; + Token NOT202=null; + + PythonTree LESS190_tree=null; + PythonTree GREATER191_tree=null; + PythonTree EQUAL192_tree=null; + PythonTree GREATEREQUAL193_tree=null; + PythonTree LESSEQUAL194_tree=null; + PythonTree ALT_NOTEQUAL195_tree=null; + PythonTree NOTEQUAL196_tree=null; + PythonTree IN197_tree=null; + PythonTree NOT198_tree=null; + PythonTree IN199_tree=null; + PythonTree IS200_tree=null; + PythonTree IS201_tree=null; + PythonTree NOT202_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1390:5: ( LESS | GREATER | EQUAL | GREATEREQUAL | LESSEQUAL | ALT_NOTEQUAL | NOTEQUAL | IN | NOT IN | IS | IS NOT ) + int alt89=11; + alt89 = dfa89.predict(input); + switch (alt89) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1390:7: LESS + { + root_0 = (PythonTree)adaptor.nil(); + + LESS190=(Token)match(input,LESS,FOLLOW_LESS_in_comp_op4745); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LESS190_tree = (PythonTree)adaptor.create(LESS190); + adaptor.addChild(root_0, LESS190_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.Lt; + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1394:7: GREATER + { + root_0 = (PythonTree)adaptor.nil(); + + GREATER191=(Token)match(input,GREATER,FOLLOW_GREATER_in_comp_op4761); if (state.failed) return retval; + if ( state.backtracking==0 ) { + GREATER191_tree = (PythonTree)adaptor.create(GREATER191); + adaptor.addChild(root_0, GREATER191_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.Gt; + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1398:7: EQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + EQUAL192=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_comp_op4777); if (state.failed) return retval; + if ( state.backtracking==0 ) { + EQUAL192_tree = (PythonTree)adaptor.create(EQUAL192); + adaptor.addChild(root_0, EQUAL192_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.Eq; + + } + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1402:7: GREATEREQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + GREATEREQUAL193=(Token)match(input,GREATEREQUAL,FOLLOW_GREATEREQUAL_in_comp_op4793); if (state.failed) return retval; + if ( state.backtracking==0 ) { + GREATEREQUAL193_tree = (PythonTree)adaptor.create(GREATEREQUAL193); + adaptor.addChild(root_0, GREATEREQUAL193_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.GtE; + + } + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1406:7: LESSEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + LESSEQUAL194=(Token)match(input,LESSEQUAL,FOLLOW_LESSEQUAL_in_comp_op4809); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LESSEQUAL194_tree = (PythonTree)adaptor.create(LESSEQUAL194); + adaptor.addChild(root_0, LESSEQUAL194_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.LtE; + + } + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1410:7: ALT_NOTEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + ALT_NOTEQUAL195=(Token)match(input,ALT_NOTEQUAL,FOLLOW_ALT_NOTEQUAL_in_comp_op4825); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ALT_NOTEQUAL195_tree = (PythonTree)adaptor.create(ALT_NOTEQUAL195); + adaptor.addChild(root_0, ALT_NOTEQUAL195_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.NotEq; + + } + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1414:7: NOTEQUAL + { + root_0 = (PythonTree)adaptor.nil(); + + NOTEQUAL196=(Token)match(input,NOTEQUAL,FOLLOW_NOTEQUAL_in_comp_op4841); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NOTEQUAL196_tree = (PythonTree)adaptor.create(NOTEQUAL196); + adaptor.addChild(root_0, NOTEQUAL196_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.NotEq; + + } + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1418:7: IN + { + root_0 = (PythonTree)adaptor.nil(); + + IN197=(Token)match(input,IN,FOLLOW_IN_in_comp_op4857); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN197_tree = (PythonTree)adaptor.create(IN197); + adaptor.addChild(root_0, IN197_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.In; + + } + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1422:7: NOT IN + { + root_0 = (PythonTree)adaptor.nil(); + + NOT198=(Token)match(input,NOT,FOLLOW_NOT_in_comp_op4873); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NOT198_tree = (PythonTree)adaptor.create(NOT198); + adaptor.addChild(root_0, NOT198_tree); + } + IN199=(Token)match(input,IN,FOLLOW_IN_in_comp_op4875); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN199_tree = (PythonTree)adaptor.create(IN199); + adaptor.addChild(root_0, IN199_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.NotIn; + + } + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1426:7: IS + { + root_0 = (PythonTree)adaptor.nil(); + + IS200=(Token)match(input,IS,FOLLOW_IS_in_comp_op4891); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IS200_tree = (PythonTree)adaptor.create(IS200); + adaptor.addChild(root_0, IS200_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.Is; + + } + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1430:7: IS NOT + { + root_0 = (PythonTree)adaptor.nil(); + + IS201=(Token)match(input,IS,FOLLOW_IS_in_comp_op4907); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IS201_tree = (PythonTree)adaptor.create(IS201); + adaptor.addChild(root_0, IS201_tree); + } + NOT202=(Token)match(input,NOT,FOLLOW_NOT_in_comp_op4909); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NOT202_tree = (PythonTree)adaptor.create(NOT202); + adaptor.addChild(root_0, NOT202_tree); + } + if ( state.backtracking==0 ) { + + retval.op = cmpopType.IsNot; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "comp_op" + + protected static class expr_scope { + expr_contextType ctype; + } + protected Stack expr_stack = new Stack(); + + public static class expr_return extends ParserRuleReturnScope { + public Token leftTok; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1437:1: expr[expr_contextType ect] returns [Token leftTok] : left= xor_expr ( (op= VBAR right+= xor_expr )+ | -> $left) ; + public final PythonParser.expr_return expr(expr_contextType ect) throws RecognitionException { + expr_stack.push(new expr_scope()); + PythonParser.expr_return retval = new PythonParser.expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token op=null; + List list_right=null; + PythonParser.xor_expr_return left = null; + + PythonParser.xor_expr_return right = null; + right = null; + PythonTree op_tree=null; + RewriteRuleTokenStream stream_VBAR=new RewriteRuleTokenStream(adaptor,"token VBAR"); + RewriteRuleSubtreeStream stream_xor_expr=new RewriteRuleSubtreeStream(adaptor,"rule xor_expr"); + + ((expr_scope)expr_stack.peek()).ctype = ect; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1455:5: (left= xor_expr ( (op= VBAR right+= xor_expr )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1455:7: left= xor_expr ( (op= VBAR right+= xor_expr )+ | -> $left) + { + pushFollow(FOLLOW_xor_expr_in_expr4961); + left=xor_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_xor_expr.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1456:9: ( (op= VBAR right+= xor_expr )+ | -> $left) + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==VBAR) ) { + alt91=1; + } + else if ( (LA91_0==EOF||LA91_0==NEWLINE||(LA91_0>=AND && LA91_0<=AS)||LA91_0==FOR||LA91_0==IF||(LA91_0>=IN && LA91_0<=IS)||(LA91_0>=NOT && LA91_0<=ORELSE)||(LA91_0>=RPAREN && LA91_0<=COMMA)||(LA91_0>=SEMI && LA91_0<=DOUBLESLASHEQUAL)||(LA91_0>=LESS && LA91_0<=NOTEQUAL)||LA91_0==RBRACK||(LA91_0>=RCURLY && LA91_0<=BACKQUOTE)) ) { + alt91=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 91, 0, input); + + throw nvae; + } + switch (alt91) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1456:11: (op= VBAR right+= xor_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1456:11: (op= VBAR right+= xor_expr )+ + int cnt90=0; + loop90: + do { + int alt90=2; + int LA90_0 = input.LA(1); + + if ( (LA90_0==VBAR) ) { + alt90=1; + } + + + switch (alt90) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1456:12: op= VBAR right+= xor_expr + { + op=(Token)match(input,VBAR,FOLLOW_VBAR_in_expr4976); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_VBAR.add(op); + + pushFollow(FOLLOW_xor_expr_in_expr4980); + right=xor_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_xor_expr.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + + } + break; + + default : + if ( cnt90 >= 1 ) break loop90; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(90, input); + throw eee; + } + cnt90++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1459:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1459:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.leftTok = (left!=null?left.lparen:null); + if (op != null) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), operatorType.BitOr, list_right); + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + expr_stack.pop(); + } + return retval; + } + // $ANTLR end "expr" + + public static class xor_expr_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "xor_expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1465:1: xor_expr returns [Token lparen = null] : left= and_expr ( (op= CIRCUMFLEX right+= and_expr )+ | -> $left) ; + public final PythonParser.xor_expr_return xor_expr() throws RecognitionException { + PythonParser.xor_expr_return retval = new PythonParser.xor_expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token op=null; + List list_right=null; + PythonParser.and_expr_return left = null; + + PythonParser.and_expr_return right = null; + right = null; + PythonTree op_tree=null; + RewriteRuleTokenStream stream_CIRCUMFLEX=new RewriteRuleTokenStream(adaptor,"token CIRCUMFLEX"); + RewriteRuleSubtreeStream stream_and_expr=new RewriteRuleSubtreeStream(adaptor,"rule and_expr"); + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1477:5: (left= and_expr ( (op= CIRCUMFLEX right+= and_expr )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1477:7: left= and_expr ( (op= CIRCUMFLEX right+= and_expr )+ | -> $left) + { + pushFollow(FOLLOW_and_expr_in_xor_expr5059); + left=and_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_and_expr.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1478:9: ( (op= CIRCUMFLEX right+= and_expr )+ | -> $left) + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==CIRCUMFLEX) ) { + alt93=1; + } + else if ( (LA93_0==EOF||LA93_0==NEWLINE||(LA93_0>=AND && LA93_0<=AS)||LA93_0==FOR||LA93_0==IF||(LA93_0>=IN && LA93_0<=IS)||(LA93_0>=NOT && LA93_0<=ORELSE)||(LA93_0>=RPAREN && LA93_0<=COMMA)||(LA93_0>=SEMI && LA93_0<=DOUBLESLASHEQUAL)||(LA93_0>=LESS && LA93_0<=VBAR)||LA93_0==RBRACK||(LA93_0>=RCURLY && LA93_0<=BACKQUOTE)) ) { + alt93=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 93, 0, input); + + throw nvae; + } + switch (alt93) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1478:11: (op= CIRCUMFLEX right+= and_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1478:11: (op= CIRCUMFLEX right+= and_expr )+ + int cnt92=0; + loop92: + do { + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==CIRCUMFLEX) ) { + alt92=1; + } + + + switch (alt92) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1478:12: op= CIRCUMFLEX right+= and_expr + { + op=(Token)match(input,CIRCUMFLEX,FOLLOW_CIRCUMFLEX_in_xor_expr5074); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_CIRCUMFLEX.add(op); + + pushFollow(FOLLOW_and_expr_in_xor_expr5078); + right=and_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_and_expr.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + + } + break; + + default : + if ( cnt92 >= 1 ) break loop92; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(92, input); + throw eee; + } + cnt92++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1481:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1481:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (op != null) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), operatorType.BitXor, list_right); + } + retval.lparen = (left!=null?left.lparen:null); + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "xor_expr" + + public static class and_expr_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "and_expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1486:1: and_expr returns [Token lparen = null] : left= shift_expr ( (op= AMPER right+= shift_expr )+ | -> $left) ; + public final PythonParser.and_expr_return and_expr() throws RecognitionException { + PythonParser.and_expr_return retval = new PythonParser.and_expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token op=null; + List list_right=null; + PythonParser.shift_expr_return left = null; + + PythonParser.shift_expr_return right = null; + right = null; + PythonTree op_tree=null; + RewriteRuleTokenStream stream_AMPER=new RewriteRuleTokenStream(adaptor,"token AMPER"); + RewriteRuleSubtreeStream stream_shift_expr=new RewriteRuleSubtreeStream(adaptor,"rule shift_expr"); + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1498:5: (left= shift_expr ( (op= AMPER right+= shift_expr )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1498:7: left= shift_expr ( (op= AMPER right+= shift_expr )+ | -> $left) + { + pushFollow(FOLLOW_shift_expr_in_and_expr5156); + left=shift_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_shift_expr.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1499:9: ( (op= AMPER right+= shift_expr )+ | -> $left) + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==AMPER) ) { + alt95=1; + } + else if ( (LA95_0==EOF||LA95_0==NEWLINE||(LA95_0>=AND && LA95_0<=AS)||LA95_0==FOR||LA95_0==IF||(LA95_0>=IN && LA95_0<=IS)||(LA95_0>=NOT && LA95_0<=ORELSE)||(LA95_0>=RPAREN && LA95_0<=COMMA)||(LA95_0>=SEMI && LA95_0<=DOUBLESLASHEQUAL)||(LA95_0>=LESS && LA95_0<=CIRCUMFLEX)||LA95_0==RBRACK||(LA95_0>=RCURLY && LA95_0<=BACKQUOTE)) ) { + alt95=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 95, 0, input); + + throw nvae; + } + switch (alt95) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1499:11: (op= AMPER right+= shift_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1499:11: (op= AMPER right+= shift_expr )+ + int cnt94=0; + loop94: + do { + int alt94=2; + int LA94_0 = input.LA(1); + + if ( (LA94_0==AMPER) ) { + alt94=1; + } + + + switch (alt94) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1499:12: op= AMPER right+= shift_expr + { + op=(Token)match(input,AMPER,FOLLOW_AMPER_in_and_expr5171); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_AMPER.add(op); + + pushFollow(FOLLOW_shift_expr_in_and_expr5175); + right=shift_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_shift_expr.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + + } + break; + + default : + if ( cnt94 >= 1 ) break loop94; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(94, input); + throw eee; + } + cnt94++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1502:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1502:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (op != null) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), operatorType.BitAnd, list_right); + } + retval.lparen = (left!=null?left.lparen:null); + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "and_expr" + + public static class shift_expr_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "shift_expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1507:1: shift_expr returns [Token lparen = null] : left= arith_expr ( ( shift_op right+= arith_expr )+ | -> $left) ; + public final PythonParser.shift_expr_return shift_expr() throws RecognitionException { + PythonParser.shift_expr_return retval = new PythonParser.shift_expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + List list_right=null; + PythonParser.arith_expr_return left = null; + + PythonParser.shift_op_return shift_op203 = null; + + PythonParser.arith_expr_return right = null; + right = null; + RewriteRuleSubtreeStream stream_shift_op=new RewriteRuleSubtreeStream(adaptor,"rule shift_op"); + RewriteRuleSubtreeStream stream_arith_expr=new RewriteRuleSubtreeStream(adaptor,"rule arith_expr"); + + List ops = new ArrayList(); + List toks = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1523:5: (left= arith_expr ( ( shift_op right+= arith_expr )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1523:7: left= arith_expr ( ( shift_op right+= arith_expr )+ | -> $left) + { + pushFollow(FOLLOW_arith_expr_in_shift_expr5258); + left=arith_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_arith_expr.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1524:9: ( ( shift_op right+= arith_expr )+ | -> $left) + int alt97=2; + int LA97_0 = input.LA(1); + + if ( (LA97_0==RIGHTSHIFT||LA97_0==LEFTSHIFT) ) { + alt97=1; + } + else if ( (LA97_0==EOF||LA97_0==NEWLINE||(LA97_0>=AND && LA97_0<=AS)||LA97_0==FOR||LA97_0==IF||(LA97_0>=IN && LA97_0<=IS)||(LA97_0>=NOT && LA97_0<=ORELSE)||(LA97_0>=RPAREN && LA97_0<=COMMA)||(LA97_0>=SEMI && LA97_0<=DOUBLESLASHEQUAL)||(LA97_0>=LESS && LA97_0<=AMPER)||LA97_0==RBRACK||(LA97_0>=RCURLY && LA97_0<=BACKQUOTE)) ) { + alt97=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 97, 0, input); + + throw nvae; + } + switch (alt97) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1524:11: ( shift_op right+= arith_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1524:11: ( shift_op right+= arith_expr )+ + int cnt96=0; + loop96: + do { + int alt96=2; + int LA96_0 = input.LA(1); + + if ( (LA96_0==RIGHTSHIFT||LA96_0==LEFTSHIFT) ) { + alt96=1; + } + + + switch (alt96) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1524:13: shift_op right+= arith_expr + { + pushFollow(FOLLOW_shift_op_in_shift_expr5272); + shift_op203=shift_op(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_shift_op.add(shift_op203.getTree()); + pushFollow(FOLLOW_arith_expr_in_shift_expr5276); + right=arith_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_arith_expr.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + if ( state.backtracking==0 ) { + + ops.add((shift_op203!=null?shift_op203.op:null)); + toks.add((shift_op203!=null?((Token)shift_op203.start):null)); + + } + + } + break; + + default : + if ( cnt96 >= 1 ) break loop96; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(96, input); + throw eee; + } + cnt96++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1531:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1531:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (!ops.isEmpty()) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), ops, list_right, toks); + } + retval.lparen = (left!=null?left.lparen:null); + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "shift_expr" + + public static class shift_op_return extends ParserRuleReturnScope { + public operatorType op; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "shift_op" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1535:1: shift_op returns [operatorType op] : ( LEFTSHIFT | RIGHTSHIFT ); + public final PythonParser.shift_op_return shift_op() throws RecognitionException { + PythonParser.shift_op_return retval = new PythonParser.shift_op_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LEFTSHIFT204=null; + Token RIGHTSHIFT205=null; + + PythonTree LEFTSHIFT204_tree=null; + PythonTree RIGHTSHIFT205_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1537:5: ( LEFTSHIFT | RIGHTSHIFT ) + int alt98=2; + int LA98_0 = input.LA(1); + + if ( (LA98_0==LEFTSHIFT) ) { + alt98=1; + } + else if ( (LA98_0==RIGHTSHIFT) ) { + alt98=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 98, 0, input); + + throw nvae; + } + switch (alt98) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1537:7: LEFTSHIFT + { + root_0 = (PythonTree)adaptor.nil(); + + LEFTSHIFT204=(Token)match(input,LEFTSHIFT,FOLLOW_LEFTSHIFT_in_shift_op5360); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LEFTSHIFT204_tree = (PythonTree)adaptor.create(LEFTSHIFT204); + adaptor.addChild(root_0, LEFTSHIFT204_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.LShift; + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1541:7: RIGHTSHIFT + { + root_0 = (PythonTree)adaptor.nil(); + + RIGHTSHIFT205=(Token)match(input,RIGHTSHIFT,FOLLOW_RIGHTSHIFT_in_shift_op5376); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RIGHTSHIFT205_tree = (PythonTree)adaptor.create(RIGHTSHIFT205); + adaptor.addChild(root_0, RIGHTSHIFT205_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.RShift; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "shift_op" + + public static class arith_expr_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "arith_expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1548:1: arith_expr returns [Token lparen = null] : left= term ( ( arith_op right+= term )+ | -> $left) ; + public final PythonParser.arith_expr_return arith_expr() throws RecognitionException { + PythonParser.arith_expr_return retval = new PythonParser.arith_expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + List list_right=null; + PythonParser.term_return left = null; + + PythonParser.arith_op_return arith_op206 = null; + + PythonParser.term_return right = null; + right = null; + RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term"); + RewriteRuleSubtreeStream stream_arith_op=new RewriteRuleSubtreeStream(adaptor,"rule arith_op"); + + List ops = new ArrayList(); + List toks = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1564:5: (left= term ( ( arith_op right+= term )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1564:7: left= term ( ( arith_op right+= term )+ | -> $left) + { + pushFollow(FOLLOW_term_in_arith_expr5422); + left=term(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_term.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1565:9: ( ( arith_op right+= term )+ | -> $left) + int alt100=2; + int LA100_0 = input.LA(1); + + if ( ((LA100_0>=PLUS && LA100_0<=MINUS)) ) { + alt100=1; + } + else if ( (LA100_0==EOF||LA100_0==NEWLINE||(LA100_0>=AND && LA100_0<=AS)||LA100_0==FOR||LA100_0==IF||(LA100_0>=IN && LA100_0<=IS)||(LA100_0>=NOT && LA100_0<=ORELSE)||(LA100_0>=RPAREN && LA100_0<=COMMA)||(LA100_0>=SEMI && LA100_0<=LEFTSHIFT)||LA100_0==RBRACK||(LA100_0>=RCURLY && LA100_0<=BACKQUOTE)) ) { + alt100=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 100, 0, input); + + throw nvae; + } + switch (alt100) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1565:11: ( arith_op right+= term )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1565:11: ( arith_op right+= term )+ + int cnt99=0; + loop99: + do { + int alt99=2; + int LA99_0 = input.LA(1); + + if ( ((LA99_0>=PLUS && LA99_0<=MINUS)) ) { + alt99=1; + } + + + switch (alt99) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1565:12: arith_op right+= term + { + pushFollow(FOLLOW_arith_op_in_arith_expr5435); + arith_op206=arith_op(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_arith_op.add(arith_op206.getTree()); + pushFollow(FOLLOW_term_in_arith_expr5439); + right=term(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_term.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + if ( state.backtracking==0 ) { + + ops.add((arith_op206!=null?arith_op206.op:null)); + toks.add((arith_op206!=null?((Token)arith_op206.start):null)); + + } + + } + break; + + default : + if ( cnt99 >= 1 ) break loop99; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(99, input); + throw eee; + } + cnt99++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1572:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1572:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (!ops.isEmpty()) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), ops, list_right, toks); + } + retval.lparen = (left!=null?left.lparen:null); + + } + } + catch (RewriteCardinalityException rce) { + + PythonTree badNode = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), null); + retval.tree = badNode; + errorHandler.error("Internal Parser Error", badNode); + + } + finally { + } + return retval; + } + // $ANTLR end "arith_expr" + + public static class arith_op_return extends ParserRuleReturnScope { + public operatorType op; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "arith_op" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1584:1: arith_op returns [operatorType op] : ( PLUS | MINUS ); + public final PythonParser.arith_op_return arith_op() throws RecognitionException { + PythonParser.arith_op_return retval = new PythonParser.arith_op_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token PLUS207=null; + Token MINUS208=null; + + PythonTree PLUS207_tree=null; + PythonTree MINUS208_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1586:5: ( PLUS | MINUS ) + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==PLUS) ) { + alt101=1; + } + else if ( (LA101_0==MINUS) ) { + alt101=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 101, 0, input); + + throw nvae; + } + switch (alt101) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1586:7: PLUS + { + root_0 = (PythonTree)adaptor.nil(); + + PLUS207=(Token)match(input,PLUS,FOLLOW_PLUS_in_arith_op5547); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PLUS207_tree = (PythonTree)adaptor.create(PLUS207); + adaptor.addChild(root_0, PLUS207_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Add; + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1590:7: MINUS + { + root_0 = (PythonTree)adaptor.nil(); + + MINUS208=(Token)match(input,MINUS,FOLLOW_MINUS_in_arith_op5563); if (state.failed) return retval; + if ( state.backtracking==0 ) { + MINUS208_tree = (PythonTree)adaptor.create(MINUS208); + adaptor.addChild(root_0, MINUS208_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Sub; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "arith_op" + + public static class term_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "term" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1597:1: term returns [Token lparen = null] : left= factor ( ( term_op right+= factor )+ | -> $left) ; + public final PythonParser.term_return term() throws RecognitionException { + PythonParser.term_return retval = new PythonParser.term_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + List list_right=null; + PythonParser.factor_return left = null; + + PythonParser.term_op_return term_op209 = null; + + PythonParser.factor_return right = null; + right = null; + RewriteRuleSubtreeStream stream_term_op=new RewriteRuleSubtreeStream(adaptor,"rule term_op"); + RewriteRuleSubtreeStream stream_factor=new RewriteRuleSubtreeStream(adaptor,"rule factor"); + + List ops = new ArrayList(); + List toks = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1613:5: (left= factor ( ( term_op right+= factor )+ | -> $left) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1613:7: left= factor ( ( term_op right+= factor )+ | -> $left) + { + pushFollow(FOLLOW_factor_in_term5609); + left=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_factor.add(left.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1614:9: ( ( term_op right+= factor )+ | -> $left) + int alt103=2; + int LA103_0 = input.LA(1); + + if ( (LA103_0==STAR||(LA103_0>=SLASH && LA103_0<=DOUBLESLASH)) ) { + alt103=1; + } + else if ( (LA103_0==EOF||LA103_0==NEWLINE||(LA103_0>=AND && LA103_0<=AS)||LA103_0==FOR||LA103_0==IF||(LA103_0>=IN && LA103_0<=IS)||(LA103_0>=NOT && LA103_0<=ORELSE)||(LA103_0>=RPAREN && LA103_0<=COMMA)||(LA103_0>=SEMI && LA103_0<=MINUS)||LA103_0==RBRACK||(LA103_0>=RCURLY && LA103_0<=BACKQUOTE)) ) { + alt103=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 103, 0, input); + + throw nvae; + } + switch (alt103) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1614:11: ( term_op right+= factor )+ + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1614:11: ( term_op right+= factor )+ + int cnt102=0; + loop102: + do { + int alt102=2; + int LA102_0 = input.LA(1); + + if ( (LA102_0==STAR||(LA102_0>=SLASH && LA102_0<=DOUBLESLASH)) ) { + alt102=1; + } + + + switch (alt102) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1614:12: term_op right+= factor + { + pushFollow(FOLLOW_term_op_in_term5622); + term_op209=term_op(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_term_op.add(term_op209.getTree()); + pushFollow(FOLLOW_factor_in_term5626); + right=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_factor.add(right.getTree()); + if (list_right==null) list_right=new ArrayList(); + list_right.add(right.getTree()); + + if ( state.backtracking==0 ) { + + ops.add((term_op209!=null?term_op209.op:null)); + toks.add((term_op209!=null?((Token)term_op209.start):null)); + + } + + } + break; + + default : + if ( cnt102 >= 1 ) break loop102; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(102, input); + throw eee; + } + cnt102++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1621:8: + { + + // AST REWRITE + // elements: left + // token labels: + // rule labels: left, retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null); + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1621:8: -> $left + { + adaptor.addChild(root_0, stream_left.nextTree()); + + } + + retval.tree = root_0;} + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.lparen = (left!=null?left.lparen:null); + if (!ops.isEmpty()) { + Token tok = (left!=null?((Token)left.start):null); + if ((left!=null?left.lparen:null) != null) { + tok = (left!=null?left.lparen:null); + } + retval.tree = actions.makeBinOp(tok, (left!=null?((PythonTree)left.tree):null), ops, list_right, toks); + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "term" + + public static class term_op_return extends ParserRuleReturnScope { + public operatorType op; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "term_op" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1625:1: term_op returns [operatorType op] : ( STAR | SLASH | PERCENT | DOUBLESLASH ); + public final PythonParser.term_op_return term_op() throws RecognitionException { + PythonParser.term_op_return retval = new PythonParser.term_op_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token STAR210=null; + Token SLASH211=null; + Token PERCENT212=null; + Token DOUBLESLASH213=null; + + PythonTree STAR210_tree=null; + PythonTree SLASH211_tree=null; + PythonTree PERCENT212_tree=null; + PythonTree DOUBLESLASH213_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1627:5: ( STAR | SLASH | PERCENT | DOUBLESLASH ) + int alt104=4; + switch ( input.LA(1) ) { + case STAR: + { + alt104=1; + } + break; + case SLASH: + { + alt104=2; + } + break; + case PERCENT: + { + alt104=3; + } + break; + case DOUBLESLASH: + { + alt104=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 104, 0, input); + + throw nvae; + } + + switch (alt104) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1627:7: STAR + { + root_0 = (PythonTree)adaptor.nil(); + + STAR210=(Token)match(input,STAR,FOLLOW_STAR_in_term_op5708); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR210_tree = (PythonTree)adaptor.create(STAR210); + adaptor.addChild(root_0, STAR210_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Mult; + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1631:7: SLASH + { + root_0 = (PythonTree)adaptor.nil(); + + SLASH211=(Token)match(input,SLASH,FOLLOW_SLASH_in_term_op5724); if (state.failed) return retval; + if ( state.backtracking==0 ) { + SLASH211_tree = (PythonTree)adaptor.create(SLASH211); + adaptor.addChild(root_0, SLASH211_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Div; + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1635:7: PERCENT + { + root_0 = (PythonTree)adaptor.nil(); + + PERCENT212=(Token)match(input,PERCENT,FOLLOW_PERCENT_in_term_op5740); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PERCENT212_tree = (PythonTree)adaptor.create(PERCENT212); + adaptor.addChild(root_0, PERCENT212_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.Mod; + + } + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1639:7: DOUBLESLASH + { + root_0 = (PythonTree)adaptor.nil(); + + DOUBLESLASH213=(Token)match(input,DOUBLESLASH,FOLLOW_DOUBLESLASH_in_term_op5756); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESLASH213_tree = (PythonTree)adaptor.create(DOUBLESLASH213); + adaptor.addChild(root_0, DOUBLESLASH213_tree); + } + if ( state.backtracking==0 ) { + + retval.op = operatorType.FloorDiv; + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "term_op" + + public static class factor_return extends ParserRuleReturnScope { + public expr etype; + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "factor" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1646:1: factor returns [expr etype, Token lparen = null] : ( PLUS p= factor | MINUS m= factor | TILDE t= factor | power ); + public final PythonParser.factor_return factor() throws RecognitionException { + PythonParser.factor_return retval = new PythonParser.factor_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token PLUS214=null; + Token MINUS215=null; + Token TILDE216=null; + PythonParser.factor_return p = null; + + PythonParser.factor_return m = null; + + PythonParser.factor_return t = null; + + PythonParser.power_return power217 = null; + + + PythonTree PLUS214_tree=null; + PythonTree MINUS215_tree=null; + PythonTree TILDE216_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1651:5: ( PLUS p= factor | MINUS m= factor | TILDE t= factor | power ) + int alt105=4; + int LA105_0 = input.LA(1); + + if ( (LA105_0==PLUS) ) { + alt105=1; + } + else if ( (LA105_0==MINUS) ) { + alt105=2; + } + else if ( (LA105_0==TILDE) ) { + alt105=3; + } + else if ( (LA105_0==NAME||LA105_0==LPAREN||LA105_0==LBRACK||LA105_0==LCURLY||LA105_0==BACKQUOTE) ) { + alt105=4; + } + else if ( (LA105_0==PRINT) && ((printFunction))) { + alt105=4; + } + else if ( ((LA105_0>=INT && LA105_0<=STRING)) ) { + alt105=4; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 105, 0, input); + + throw nvae; + } + switch (alt105) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1651:7: PLUS p= factor + { + root_0 = (PythonTree)adaptor.nil(); + + PLUS214=(Token)match(input,PLUS,FOLLOW_PLUS_in_factor5795); if (state.failed) return retval; + if ( state.backtracking==0 ) { + PLUS214_tree = (PythonTree)adaptor.create(PLUS214); + adaptor.addChild(root_0, PLUS214_tree); + } + pushFollow(FOLLOW_factor_in_factor5799); + p=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, p.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = new UnaryOp(PLUS214, unaryopType.UAdd, (p!=null?p.etype:null)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1655:7: MINUS m= factor + { + root_0 = (PythonTree)adaptor.nil(); + + MINUS215=(Token)match(input,MINUS,FOLLOW_MINUS_in_factor5815); if (state.failed) return retval; + if ( state.backtracking==0 ) { + MINUS215_tree = (PythonTree)adaptor.create(MINUS215); + adaptor.addChild(root_0, MINUS215_tree); + } + pushFollow(FOLLOW_factor_in_factor5819); + m=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = actions.negate(MINUS215, (m!=null?m.etype:null)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1659:7: TILDE t= factor + { + root_0 = (PythonTree)adaptor.nil(); + + TILDE216=(Token)match(input,TILDE,FOLLOW_TILDE_in_factor5835); if (state.failed) return retval; + if ( state.backtracking==0 ) { + TILDE216_tree = (PythonTree)adaptor.create(TILDE216); + adaptor.addChild(root_0, TILDE216_tree); + } + pushFollow(FOLLOW_factor_in_factor5839); + t=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = new UnaryOp(TILDE216, unaryopType.Invert, (t!=null?t.etype:null)); + + } + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1663:7: power + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_power_in_factor5855); + power217=power(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, power217.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = actions.castExpr((power217!=null?((PythonTree)power217.tree):null)); + retval.lparen = (power217!=null?power217.lparen:null); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "factor" + + public static class power_return extends ParserRuleReturnScope { + public expr etype; + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "power" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1671:1: power returns [expr etype, Token lparen = null] : atom (t+= trailer[$atom.start, $atom.tree] )* ( options {greedy=true; } : d= DOUBLESTAR factor )? ; + public final PythonParser.power_return power() throws RecognitionException { + PythonParser.power_return retval = new PythonParser.power_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token d=null; + List list_t=null; + PythonParser.atom_return atom218 = null; + + PythonParser.factor_return factor219 = null; + + PythonParser.trailer_return t = null; + t = null; + PythonTree d_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:5: ( atom (t+= trailer[$atom.start, $atom.tree] )* ( options {greedy=true; } : d= DOUBLESTAR factor )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:7: atom (t+= trailer[$atom.start, $atom.tree] )* ( options {greedy=true; } : d= DOUBLESTAR factor )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_atom_in_power5894); + atom218=atom(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, atom218.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:12: (t+= trailer[$atom.start, $atom.tree] )* + loop106: + do { + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==DOT||LA106_0==LPAREN||LA106_0==LBRACK) ) { + alt106=1; + } + + + switch (alt106) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:13: t+= trailer[$atom.start, $atom.tree] + { + pushFollow(FOLLOW_trailer_in_power5899); + t=trailer((atom218!=null?((Token)atom218.start):null), (atom218!=null?((PythonTree)atom218.tree):null)); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop106; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:51: ( options {greedy=true; } : d= DOUBLESTAR factor )? + int alt107=2; + int LA107_0 = input.LA(1); + + if ( (LA107_0==DOUBLESTAR) ) { + alt107=1; + } + switch (alt107) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1676:75: d= DOUBLESTAR factor + { + d=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_power5914); if (state.failed) return retval; + if ( state.backtracking==0 ) { + d_tree = (PythonTree)adaptor.create(d); + adaptor.addChild(root_0, d_tree); + } + pushFollow(FOLLOW_factor_in_power5916); + factor219=factor(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, factor219.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.lparen = (atom218!=null?atom218.lparen:null); + //XXX: This could be better. + retval.etype = actions.castExpr((atom218!=null?((PythonTree)atom218.tree):null)); + if (list_t != null) { + for(Object o : list_t) { + actions.recurseSetContext(retval.etype, expr_contextType.Load); + if (o instanceof Call) { + Call c = (Call)o; + c.setFunc((PyObject)retval.etype); + retval.etype = c; + } else if (o instanceof Subscript) { + Subscript c = (Subscript)o; + c.setValue((PyObject)retval.etype); + retval.etype = c; + } else if (o instanceof Attribute) { + Attribute c = (Attribute)o; + c.setCharStartIndex(retval.etype.getCharStartIndex()); + c.setValue((PyObject)retval.etype); + retval.etype = c; + } + } + } + if (d != null) { + List right = new ArrayList(); + right.add((factor219!=null?((PythonTree)factor219.tree):null)); + retval.etype = actions.makeBinOp((atom218!=null?((Token)atom218.start):null), retval.etype, operatorType.Pow, right); + } + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "power" + + public static class atom_return extends ParserRuleReturnScope { + public Token lparen = null; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "atom" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1713:1: atom returns [Token lparen = null] : ( LPAREN ( yield_expr | testlist_gexp -> testlist_gexp | ) RPAREN | LBRACK ( listmaker[$LBRACK] -> listmaker | ) RBRACK | LCURLY ( dictorsetmaker[$LCURLY] -> dictorsetmaker | ) RCURLY | lb= BACKQUOTE testlist[expr_contextType.Load] rb= BACKQUOTE | name_or_print | INT | LONGINT | FLOAT | COMPLEX | (S+= STRING )+ ); + public final PythonParser.atom_return atom() throws RecognitionException { + PythonParser.atom_return retval = new PythonParser.atom_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token lb=null; + Token rb=null; + Token LPAREN220=null; + Token RPAREN223=null; + Token LBRACK224=null; + Token RBRACK226=null; + Token LCURLY227=null; + Token RCURLY229=null; + Token INT232=null; + Token LONGINT233=null; + Token FLOAT234=null; + Token COMPLEX235=null; + Token S=null; + List list_S=null; + PythonParser.yield_expr_return yield_expr221 = null; + + PythonParser.testlist_gexp_return testlist_gexp222 = null; + + PythonParser.listmaker_return listmaker225 = null; + + PythonParser.dictorsetmaker_return dictorsetmaker228 = null; + + PythonParser.testlist_return testlist230 = null; + + PythonParser.name_or_print_return name_or_print231 = null; + + + PythonTree lb_tree=null; + PythonTree rb_tree=null; + PythonTree LPAREN220_tree=null; + PythonTree RPAREN223_tree=null; + PythonTree LBRACK224_tree=null; + PythonTree RBRACK226_tree=null; + PythonTree LCURLY227_tree=null; + PythonTree RCURLY229_tree=null; + PythonTree INT232_tree=null; + PythonTree LONGINT233_tree=null; + PythonTree FLOAT234_tree=null; + PythonTree COMPLEX235_tree=null; + PythonTree S_tree=null; + RewriteRuleTokenStream stream_RBRACK=new RewriteRuleTokenStream(adaptor,"token RBRACK"); + RewriteRuleTokenStream stream_LBRACK=new RewriteRuleTokenStream(adaptor,"token LBRACK"); + RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN"); + RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY"); + RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN"); + RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY"); + RewriteRuleSubtreeStream stream_listmaker=new RewriteRuleSubtreeStream(adaptor,"rule listmaker"); + RewriteRuleSubtreeStream stream_yield_expr=new RewriteRuleSubtreeStream(adaptor,"rule yield_expr"); + RewriteRuleSubtreeStream stream_testlist_gexp=new RewriteRuleSubtreeStream(adaptor,"rule testlist_gexp"); + RewriteRuleSubtreeStream stream_dictorsetmaker=new RewriteRuleSubtreeStream(adaptor,"rule dictorsetmaker"); + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1723:5: ( LPAREN ( yield_expr | testlist_gexp -> testlist_gexp | ) RPAREN | LBRACK ( listmaker[$LBRACK] -> listmaker | ) RBRACK | LCURLY ( dictorsetmaker[$LCURLY] -> dictorsetmaker | ) RCURLY | lb= BACKQUOTE testlist[expr_contextType.Load] rb= BACKQUOTE | name_or_print | INT | LONGINT | FLOAT | COMPLEX | (S+= STRING )+ ) + int alt112=10; + alt112 = dfa112.predict(input); + switch (alt112) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1723:7: LPAREN ( yield_expr | testlist_gexp -> testlist_gexp | ) RPAREN + { + LPAREN220=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_atom5966); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN220); + + if ( state.backtracking==0 ) { + + retval.lparen = LPAREN220; + + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1727:7: ( yield_expr | testlist_gexp -> testlist_gexp | ) + int alt108=3; + int LA108_0 = input.LA(1); + + if ( (LA108_0==YIELD) ) { + alt108=1; + } + else if ( (LA108_0==NAME||LA108_0==NOT||LA108_0==LPAREN||(LA108_0>=PLUS && LA108_0<=MINUS)||(LA108_0>=TILDE && LA108_0<=LBRACK)||LA108_0==LCURLY||LA108_0==BACKQUOTE) ) { + alt108=2; + } + else if ( (LA108_0==PRINT) && ((printFunction))) { + alt108=2; + } + else if ( (LA108_0==LAMBDA||(LA108_0>=INT && LA108_0<=STRING)) ) { + alt108=2; + } + else if ( (LA108_0==RPAREN) ) { + alt108=3; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 108, 0, input); + + throw nvae; + } + switch (alt108) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1727:9: yield_expr + { + pushFollow(FOLLOW_yield_expr_in_atom5984); + yield_expr221=yield_expr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_yield_expr.add(yield_expr221.getTree()); + if ( state.backtracking==0 ) { + + etype = (yield_expr221!=null?yield_expr221.etype:null); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1731:9: testlist_gexp + { + pushFollow(FOLLOW_testlist_gexp_in_atom6004); + testlist_gexp222=testlist_gexp(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_testlist_gexp.add(testlist_gexp222.getTree()); + + + // AST REWRITE + // elements: testlist_gexp + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1732:6: -> testlist_gexp + { + adaptor.addChild(root_0, stream_testlist_gexp.nextTree()); + + } + + retval.tree = root_0;} + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1734:9: + { + if ( state.backtracking==0 ) { + + etype = new Tuple(LPAREN220, new ArrayList(), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + + } + + RPAREN223=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_atom6047); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN223); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1739:7: LBRACK ( listmaker[$LBRACK] -> listmaker | ) RBRACK + { + LBRACK224=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_atom6055); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_LBRACK.add(LBRACK224); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1740:7: ( listmaker[$LBRACK] -> listmaker | ) + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==NAME||LA109_0==NOT||LA109_0==LPAREN||(LA109_0>=PLUS && LA109_0<=MINUS)||(LA109_0>=TILDE && LA109_0<=LBRACK)||LA109_0==LCURLY||LA109_0==BACKQUOTE) ) { + alt109=1; + } + else if ( (LA109_0==PRINT) && ((printFunction))) { + alt109=1; + } + else if ( (LA109_0==LAMBDA||(LA109_0>=INT && LA109_0<=STRING)) ) { + alt109=1; + } + else if ( (LA109_0==RBRACK) ) { + alt109=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 109, 0, input); + + throw nvae; + } + switch (alt109) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1740:8: listmaker[$LBRACK] + { + pushFollow(FOLLOW_listmaker_in_atom6064); + listmaker225=listmaker(LBRACK224); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_listmaker.add(listmaker225.getTree()); + + + // AST REWRITE + // elements: listmaker + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1741:6: -> listmaker + { + adaptor.addChild(root_0, stream_listmaker.nextTree()); + + } + + retval.tree = root_0;} + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1743:8: + { + if ( state.backtracking==0 ) { + + etype = new org.python.antlr.ast.List(LBRACK224, new ArrayList(), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + + } + + RBRACK226=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_atom6107); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RBRACK.add(RBRACK226); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1748:7: LCURLY ( dictorsetmaker[$LCURLY] -> dictorsetmaker | ) RCURLY + { + LCURLY227=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_atom6115); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY227); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1749:8: ( dictorsetmaker[$LCURLY] -> dictorsetmaker | ) + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==NAME||LA110_0==NOT||LA110_0==LPAREN||(LA110_0>=PLUS && LA110_0<=MINUS)||(LA110_0>=TILDE && LA110_0<=LBRACK)||LA110_0==LCURLY||LA110_0==BACKQUOTE) ) { + alt110=1; + } + else if ( (LA110_0==PRINT) && ((printFunction))) { + alt110=1; + } + else if ( (LA110_0==LAMBDA||(LA110_0>=INT && LA110_0<=STRING)) ) { + alt110=1; + } + else if ( (LA110_0==RCURLY) ) { + alt110=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 110, 0, input); + + throw nvae; + } + switch (alt110) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1749:9: dictorsetmaker[$LCURLY] + { + pushFollow(FOLLOW_dictorsetmaker_in_atom6125); + dictorsetmaker228=dictorsetmaker(LCURLY227); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_dictorsetmaker.add(dictorsetmaker228.getTree()); + + + // AST REWRITE + // elements: dictorsetmaker + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1750:7: -> dictorsetmaker + { + adaptor.addChild(root_0, stream_dictorsetmaker.nextTree()); + + } + + retval.tree = root_0;} + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1752:9: + { + if ( state.backtracking==0 ) { + + etype = new Dict(LCURLY227, new ArrayList(), new ArrayList()); + + } + + } + break; + + } + + RCURLY229=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_atom6173); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY229); + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1757:8: lb= BACKQUOTE testlist[expr_contextType.Load] rb= BACKQUOTE + { + root_0 = (PythonTree)adaptor.nil(); + + lb=(Token)match(input,BACKQUOTE,FOLLOW_BACKQUOTE_in_atom6184); if (state.failed) return retval; + if ( state.backtracking==0 ) { + lb_tree = (PythonTree)adaptor.create(lb); + adaptor.addChild(root_0, lb_tree); + } + pushFollow(FOLLOW_testlist_in_atom6186); + testlist230=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist230.getTree()); + rb=(Token)match(input,BACKQUOTE,FOLLOW_BACKQUOTE_in_atom6191); if (state.failed) return retval; + if ( state.backtracking==0 ) { + rb_tree = (PythonTree)adaptor.create(rb); + adaptor.addChild(root_0, rb_tree); + } + if ( state.backtracking==0 ) { + + etype = new Repr(lb, actions.castExpr((testlist230!=null?((PythonTree)testlist230.tree):null))); + + } + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1761:8: name_or_print + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_name_or_print_in_atom6209); + name_or_print231=name_or_print(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, name_or_print231.getTree()); + if ( state.backtracking==0 ) { + + etype = new Name((name_or_print231!=null?((Token)name_or_print231.start):null), (name_or_print231!=null?input.toString(name_or_print231.start,name_or_print231.stop):null), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1765:8: INT + { + root_0 = (PythonTree)adaptor.nil(); + + INT232=(Token)match(input,INT,FOLLOW_INT_in_atom6227); if (state.failed) return retval; + if ( state.backtracking==0 ) { + INT232_tree = (PythonTree)adaptor.create(INT232); + adaptor.addChild(root_0, INT232_tree); + } + if ( state.backtracking==0 ) { + + etype = new Num(INT232, actions.makeInt(INT232)); + + } + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1769:8: LONGINT + { + root_0 = (PythonTree)adaptor.nil(); + + LONGINT233=(Token)match(input,LONGINT,FOLLOW_LONGINT_in_atom6245); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LONGINT233_tree = (PythonTree)adaptor.create(LONGINT233); + adaptor.addChild(root_0, LONGINT233_tree); + } + if ( state.backtracking==0 ) { + + etype = new Num(LONGINT233, actions.makeInt(LONGINT233)); + + } + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1773:8: FLOAT + { + root_0 = (PythonTree)adaptor.nil(); + + FLOAT234=(Token)match(input,FLOAT,FOLLOW_FLOAT_in_atom6263); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FLOAT234_tree = (PythonTree)adaptor.create(FLOAT234); + adaptor.addChild(root_0, FLOAT234_tree); + } + if ( state.backtracking==0 ) { + + etype = new Num(FLOAT234, actions.makeFloat(FLOAT234)); + + } + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1777:8: COMPLEX + { + root_0 = (PythonTree)adaptor.nil(); + + COMPLEX235=(Token)match(input,COMPLEX,FOLLOW_COMPLEX_in_atom6281); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMPLEX235_tree = (PythonTree)adaptor.create(COMPLEX235); + adaptor.addChild(root_0, COMPLEX235_tree); + } + if ( state.backtracking==0 ) { + + etype = new Num(COMPLEX235, actions.makeComplex(COMPLEX235)); + + } + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1781:8: (S+= STRING )+ + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1781:8: (S+= STRING )+ + int cnt111=0; + loop111: + do { + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==STRING) ) { + alt111=1; + } + + + switch (alt111) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1781:9: S+= STRING + { + S=(Token)match(input,STRING,FOLLOW_STRING_in_atom6302); if (state.failed) return retval; + if ( state.backtracking==0 ) { + S_tree = (PythonTree)adaptor.create(S); + adaptor.addChild(root_0, S_tree); + } + if (list_S==null) list_S=new ArrayList(); + list_S.add(S); + + + } + break; + + default : + if ( cnt111 >= 1 ) break loop111; + if (state.backtracking>0) {state.failed=true; return retval;} + EarlyExitException eee = + new EarlyExitException(111, input); + throw eee; + } + cnt111++; + } while (true); + + if ( state.backtracking==0 ) { + + etype = new Str(actions.extractStringToken(list_S), actions.extractStrings(list_S, encoding, unicodeLiterals)); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "atom" + + public static class listmaker_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "listmaker" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1788:1: listmaker[Token lbrack] : t+= test[$expr::ctype] ( list_for[gens] | ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* ) ( COMMA )? ; + public final PythonParser.listmaker_return listmaker(Token lbrack) throws RecognitionException { + PythonParser.listmaker_return retval = new PythonParser.listmaker_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA237=null; + Token COMMA238=null; + List list_t=null; + PythonParser.list_for_return list_for236 = null; + + PythonParser.test_return t = null; + t = null; + PythonTree COMMA237_tree=null; + PythonTree COMMA238_tree=null; + + + List gens = new ArrayList(); + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1796:5: (t+= test[$expr::ctype] ( list_for[gens] | ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* ) ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1796:7: t+= test[$expr::ctype] ( list_for[gens] | ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* ) ( COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_listmaker6345); + t=test(((expr_scope)expr_stack.peek()).ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1797:9: ( list_for[gens] | ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* ) + int alt114=2; + int LA114_0 = input.LA(1); + + if ( (LA114_0==FOR) ) { + alt114=1; + } + else if ( (LA114_0==COMMA||LA114_0==RBRACK) ) { + alt114=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 114, 0, input); + + throw nvae; + } + switch (alt114) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1797:10: list_for[gens] + { + pushFollow(FOLLOW_list_for_in_listmaker6357); + list_for236=list_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, list_for236.getTree()); + if ( state.backtracking==0 ) { + + Collections.reverse(gens); + List c = gens; + etype = new ListComp(((Token)retval.start), actions.castExpr(list_t.get(0)), c); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1803:11: ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1803:11: ( options {greedy=true; } : COMMA t+= test[$expr::ctype] )* + loop113: + do { + int alt113=2; + int LA113_0 = input.LA(1); + + if ( (LA113_0==COMMA) ) { + int LA113_1 = input.LA(2); + + if ( (LA113_1==NAME||LA113_1==PRINT||(LA113_1>=LAMBDA && LA113_1<=NOT)||LA113_1==LPAREN||(LA113_1>=PLUS && LA113_1<=MINUS)||(LA113_1>=TILDE && LA113_1<=LBRACK)||LA113_1==LCURLY||(LA113_1>=BACKQUOTE && LA113_1<=STRING)) ) { + alt113=1; + } + + + } + + + switch (alt113) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1803:35: COMMA t+= test[$expr::ctype] + { + COMMA237=(Token)match(input,COMMA,FOLLOW_COMMA_in_listmaker6389); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA237_tree = (PythonTree)adaptor.create(COMMA237); + adaptor.addChild(root_0, COMMA237_tree); + } + pushFollow(FOLLOW_test_in_listmaker6393); + t=test(((expr_scope)expr_stack.peek()).ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop113; + } + } while (true); + + if ( state.backtracking==0 ) { + + etype = new org.python.antlr.ast.List(lbrack, actions.castExprs(list_t), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1807:11: ( COMMA )? + int alt115=2; + int LA115_0 = input.LA(1); + + if ( (LA115_0==COMMA) ) { + alt115=1; + } + switch (alt115) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1807:12: COMMA + { + COMMA238=(Token)match(input,COMMA,FOLLOW_COMMA_in_listmaker6422); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA238_tree = (PythonTree)adaptor.create(COMMA238); + adaptor.addChild(root_0, COMMA238_tree); + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "listmaker" + + public static class testlist_gexp_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "testlist_gexp" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1811:1: testlist_gexp : t+= test[$expr::ctype] ( ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* (c2= COMMA )? {...}? | -> test | ( comp_for[gens] ) ) ; + public final PythonParser.testlist_gexp_return testlist_gexp() throws RecognitionException { + PythonParser.testlist_gexp_return retval = new PythonParser.testlist_gexp_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token c1=null; + Token c2=null; + List list_t=null; + PythonParser.comp_for_return comp_for239 = null; + + PythonParser.test_return t = null; + t = null; + PythonTree c1_tree=null; + PythonTree c2_tree=null; + RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); + RewriteRuleSubtreeStream stream_test=new RewriteRuleSubtreeStream(adaptor,"rule test"); + RewriteRuleSubtreeStream stream_comp_for=new RewriteRuleSubtreeStream(adaptor,"rule comp_for"); + + expr etype = null; + List gens = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1821:5: (t+= test[$expr::ctype] ( ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* (c2= COMMA )? {...}? | -> test | ( comp_for[gens] ) ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1821:7: t+= test[$expr::ctype] ( ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* (c2= COMMA )? {...}? | -> test | ( comp_for[gens] ) ) + { + pushFollow(FOLLOW_test_in_testlist_gexp6454); + t=test(((expr_scope)expr_stack.peek()).ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_test.add(t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:9: ( ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* (c2= COMMA )? {...}? | -> test | ( comp_for[gens] ) ) + int alt118=3; + switch ( input.LA(1) ) { + case COMMA: + { + alt118=1; + } + break; + case RPAREN: + { + int LA118_2 = input.LA(2); + + if ( (( c1 != null || c2 != null )) ) { + alt118=1; + } + else if ( (true) ) { + alt118=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 118, 2, input); + + throw nvae; + } + } + break; + case FOR: + { + alt118=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 118, 0, input); + + throw nvae; + } + + switch (alt118) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:11: ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* (c2= COMMA )? {...}? + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:11: ( options {k=2; } : c1= COMMA t+= test[$expr::ctype] )* + loop116: + do { + int alt116=2; + alt116 = dfa116.predict(input); + switch (alt116) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:28: c1= COMMA t+= test[$expr::ctype] + { + c1=(Token)match(input,COMMA,FOLLOW_COMMA_in_testlist_gexp6478); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_COMMA.add(c1); + + pushFollow(FOLLOW_test_in_testlist_gexp6482); + t=test(((expr_scope)expr_stack.peek()).ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_test.add(t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop116; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:61: (c2= COMMA )? + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==COMMA) ) { + alt117=1; + } + switch (alt117) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1822:62: c2= COMMA + { + c2=(Token)match(input,COMMA,FOLLOW_COMMA_in_testlist_gexp6490); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_COMMA.add(c2); + + + } + break; + + } + + if ( !(( c1 != null || c2 != null )) ) { + if (state.backtracking>0) {state.failed=true; return retval;} + throw new FailedPredicateException(input, "testlist_gexp", " $c1 != null || $c2 != null "); + } + if ( state.backtracking==0 ) { + + etype = new Tuple(((Token)retval.start), actions.castExprs(list_t), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1827:11: + { + + // AST REWRITE + // elements: test + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1827:11: -> test + { + adaptor.addChild(root_0, stream_test.nextTree()); + + } + + retval.tree = root_0;} + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1828:11: ( comp_for[gens] ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1828:11: ( comp_for[gens] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1828:12: comp_for[gens] + { + pushFollow(FOLLOW_comp_for_in_testlist_gexp6544); + comp_for239=comp_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_comp_for.add(comp_for239.getTree()); + if ( state.backtracking==0 ) { + + Collections.reverse(gens); + List c = gens; + expr e = actions.castExpr(list_t.get(0)); + if (e instanceof Context) { + ((Context)e).setContext(expr_contextType.Load); + } + etype = new GeneratorExp(((Token)retval.start), actions.castExpr(list_t.get(0)), c); + + } + + } + + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "testlist_gexp" + + public static class lambdef_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "lambdef" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1843:1: lambdef : LAMBDA ( varargslist )? COLON test[expr_contextType.Load] ; + public final PythonParser.lambdef_return lambdef() throws RecognitionException { + PythonParser.lambdef_return retval = new PythonParser.lambdef_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LAMBDA240=null; + Token COLON242=null; + PythonParser.varargslist_return varargslist241 = null; + + PythonParser.test_return test243 = null; + + + PythonTree LAMBDA240_tree=null; + PythonTree COLON242_tree=null; + + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1850:5: ( LAMBDA ( varargslist )? COLON test[expr_contextType.Load] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1850:7: LAMBDA ( varargslist )? COLON test[expr_contextType.Load] + { + root_0 = (PythonTree)adaptor.nil(); + + LAMBDA240=(Token)match(input,LAMBDA,FOLLOW_LAMBDA_in_lambdef6608); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LAMBDA240_tree = (PythonTree)adaptor.create(LAMBDA240); + adaptor.addChild(root_0, LAMBDA240_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1850:14: ( varargslist )? + int alt119=2; + int LA119_0 = input.LA(1); + + if ( (LA119_0==NAME||LA119_0==LPAREN||(LA119_0>=STAR && LA119_0<=DOUBLESTAR)) ) { + alt119=1; + } + switch (alt119) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1850:15: varargslist + { + pushFollow(FOLLOW_varargslist_in_lambdef6611); + varargslist241=varargslist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, varargslist241.getTree()); + + } + break; + + } + + COLON242=(Token)match(input,COLON,FOLLOW_COLON_in_lambdef6615); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON242_tree = (PythonTree)adaptor.create(COLON242); + adaptor.addChild(root_0, COLON242_tree); + } + pushFollow(FOLLOW_test_in_lambdef6617); + test243=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test243.getTree()); + if ( state.backtracking==0 ) { + + arguments a = (varargslist241!=null?varargslist241.args:null); + if (a == null) { + a = new arguments(LAMBDA240, new ArrayList(), (Name)null, null, new ArrayList()); + } + etype = new Lambda(LAMBDA240, a, actions.castExpr((test243!=null?((PythonTree)test243.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "lambdef" + + public static class trailer_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "trailer" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1861:1: trailer[Token begin, PythonTree ptree] : ( LPAREN ( arglist | ) RPAREN | LBRACK subscriptlist[$begin] RBRACK | DOT attr ); + public final PythonParser.trailer_return trailer(Token begin, PythonTree ptree) throws RecognitionException { + PythonParser.trailer_return retval = new PythonParser.trailer_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token LPAREN244=null; + Token RPAREN246=null; + Token LBRACK247=null; + Token RBRACK249=null; + Token DOT250=null; + PythonParser.arglist_return arglist245 = null; + + PythonParser.subscriptlist_return subscriptlist248 = null; + + PythonParser.attr_return attr251 = null; + + + PythonTree LPAREN244_tree=null; + PythonTree RPAREN246_tree=null; + PythonTree LBRACK247_tree=null; + PythonTree RBRACK249_tree=null; + PythonTree DOT250_tree=null; + + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1870:5: ( LPAREN ( arglist | ) RPAREN | LBRACK subscriptlist[$begin] RBRACK | DOT attr ) + int alt121=3; + switch ( input.LA(1) ) { + case LPAREN: + { + alt121=1; + } + break; + case LBRACK: + { + alt121=2; + } + break; + case DOT: + { + alt121=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 121, 0, input); + + throw nvae; + } + + switch (alt121) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1870:7: LPAREN ( arglist | ) RPAREN + { + root_0 = (PythonTree)adaptor.nil(); + + LPAREN244=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_trailer6656); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN244_tree = (PythonTree)adaptor.create(LPAREN244); + adaptor.addChild(root_0, LPAREN244_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1871:7: ( arglist | ) + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==NAME||LA120_0==NOT||LA120_0==LPAREN||(LA120_0>=PLUS && LA120_0<=MINUS)||(LA120_0>=TILDE && LA120_0<=LBRACK)||LA120_0==LCURLY||LA120_0==BACKQUOTE) ) { + alt120=1; + } + else if ( (LA120_0==PRINT) && ((printFunction))) { + alt120=1; + } + else if ( (LA120_0==LAMBDA||(LA120_0>=STAR && LA120_0<=DOUBLESTAR)||(LA120_0>=INT && LA120_0<=STRING)) ) { + alt120=1; + } + else if ( (LA120_0==RPAREN) ) { + alt120=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 120, 0, input); + + throw nvae; + } + switch (alt120) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1871:8: arglist + { + pushFollow(FOLLOW_arglist_in_trailer6665); + arglist245=arglist(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, arglist245.getTree()); + if ( state.backtracking==0 ) { + + etype = new Call(begin, actions.castExpr(ptree), actions.castExprs((arglist245!=null?arglist245.args:null)), + actions.makeKeywords((arglist245!=null?arglist245.keywords:null)), (arglist245!=null?arglist245.starargs:null), (arglist245!=null?arglist245.kwargs:null)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1877:8: + { + if ( state.backtracking==0 ) { + + etype = new Call(begin, actions.castExpr(ptree), new ArrayList(), new ArrayList(), null, null); + + } + + } + break; + + } + + RPAREN246=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_trailer6707); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN246_tree = (PythonTree)adaptor.create(RPAREN246); + adaptor.addChild(root_0, RPAREN246_tree); + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1882:7: LBRACK subscriptlist[$begin] RBRACK + { + root_0 = (PythonTree)adaptor.nil(); + + LBRACK247=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_trailer6715); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LBRACK247_tree = (PythonTree)adaptor.create(LBRACK247); + adaptor.addChild(root_0, LBRACK247_tree); + } + pushFollow(FOLLOW_subscriptlist_in_trailer6717); + subscriptlist248=subscriptlist(begin); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, subscriptlist248.getTree()); + RBRACK249=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_trailer6720); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RBRACK249_tree = (PythonTree)adaptor.create(RBRACK249); + adaptor.addChild(root_0, RBRACK249_tree); + } + if ( state.backtracking==0 ) { + + etype = new Subscript(begin, actions.castExpr(ptree), actions.castSlice((subscriptlist248!=null?((PythonTree)subscriptlist248.tree):null)), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1886:7: DOT attr + { + root_0 = (PythonTree)adaptor.nil(); + + DOT250=(Token)match(input,DOT,FOLLOW_DOT_in_trailer6736); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOT250_tree = (PythonTree)adaptor.create(DOT250); + adaptor.addChild(root_0, DOT250_tree); + } + pushFollow(FOLLOW_attr_in_trailer6738); + attr251=attr(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, attr251.getTree()); + if ( state.backtracking==0 ) { + + etype = new Attribute(begin, actions.castExpr(ptree), new Name((attr251!=null?((PythonTree)attr251.tree):null), (attr251!=null?input.toString(attr251.start,attr251.stop):null), expr_contextType.Load), ((expr_scope)expr_stack.peek()).ctype); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "trailer" + + public static class subscriptlist_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "subscriptlist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1893:1: subscriptlist[Token begin] : sub+= subscript ( options {greedy=true; } : c1= COMMA sub+= subscript )* (c2= COMMA )? ; + public final PythonParser.subscriptlist_return subscriptlist(Token begin) throws RecognitionException { + PythonParser.subscriptlist_return retval = new PythonParser.subscriptlist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token c1=null; + Token c2=null; + List list_sub=null; + PythonParser.subscript_return sub = null; + sub = null; + PythonTree c1_tree=null; + PythonTree c2_tree=null; + + + slice sltype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:5: (sub+= subscript ( options {greedy=true; } : c1= COMMA sub+= subscript )* (c2= COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:7: sub+= subscript ( options {greedy=true; } : c1= COMMA sub+= subscript )* (c2= COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_subscript_in_subscriptlist6777); + sub=subscript(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, sub.getTree()); + if (list_sub==null) list_sub=new ArrayList(); + list_sub.add(sub.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:22: ( options {greedy=true; } : c1= COMMA sub+= subscript )* + loop122: + do { + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==COMMA) ) { + int LA122_1 = input.LA(2); + + if ( ((LA122_1>=NAME && LA122_1<=PRINT)||(LA122_1>=LAMBDA && LA122_1<=NOT)||LA122_1==LPAREN||LA122_1==COLON||(LA122_1>=PLUS && LA122_1<=MINUS)||(LA122_1>=TILDE && LA122_1<=LBRACK)||LA122_1==LCURLY||(LA122_1>=BACKQUOTE && LA122_1<=STRING)) ) { + alt122=1; + } + + + } + + + switch (alt122) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:46: c1= COMMA sub+= subscript + { + c1=(Token)match(input,COMMA,FOLLOW_COMMA_in_subscriptlist6789); if (state.failed) return retval; + if ( state.backtracking==0 ) { + c1_tree = (PythonTree)adaptor.create(c1); + adaptor.addChild(root_0, c1_tree); + } + pushFollow(FOLLOW_subscript_in_subscriptlist6793); + sub=subscript(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, sub.getTree()); + if (list_sub==null) list_sub=new ArrayList(); + list_sub.add(sub.getTree()); + + + } + break; + + default : + break loop122; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:72: (c2= COMMA )? + int alt123=2; + int LA123_0 = input.LA(1); + + if ( (LA123_0==COMMA) ) { + alt123=1; + } + switch (alt123) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1900:73: c2= COMMA + { + c2=(Token)match(input,COMMA,FOLLOW_COMMA_in_subscriptlist6800); if (state.failed) return retval; + if ( state.backtracking==0 ) { + c2_tree = (PythonTree)adaptor.create(c2); + adaptor.addChild(root_0, c2_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + sltype = actions.makeSliceType(begin, c1, c2, list_sub); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = sltype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "subscriptlist" + + public static class subscript_return extends ParserRuleReturnScope { + public slice sltype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "subscript" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1907:1: subscript returns [slice sltype] : (d1= DOT DOT DOT | ( test[null] COLON )=>lower= test[expr_contextType.Load] (c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? )? | ( COLON )=>c2= COLON (upper2= test[expr_contextType.Load] )? ( sliceop )? | test[expr_contextType.Load] ); + public final PythonParser.subscript_return subscript() throws RecognitionException { + PythonParser.subscript_return retval = new PythonParser.subscript_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token d1=null; + Token c1=null; + Token c2=null; + Token DOT252=null; + Token DOT253=null; + PythonParser.test_return lower = null; + + PythonParser.test_return upper1 = null; + + PythonParser.test_return upper2 = null; + + PythonParser.sliceop_return sliceop254 = null; + + PythonParser.sliceop_return sliceop255 = null; + + PythonParser.test_return test256 = null; + + + PythonTree d1_tree=null; + PythonTree c1_tree=null; + PythonTree c2_tree=null; + PythonTree DOT252_tree=null; + PythonTree DOT253_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1912:5: (d1= DOT DOT DOT | ( test[null] COLON )=>lower= test[expr_contextType.Load] (c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? )? | ( COLON )=>c2= COLON (upper2= test[expr_contextType.Load] )? ( sliceop )? | test[expr_contextType.Load] ) + int alt129=4; + alt129 = dfa129.predict(input); + switch (alt129) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1912:7: d1= DOT DOT DOT + { + root_0 = (PythonTree)adaptor.nil(); + + d1=(Token)match(input,DOT,FOLLOW_DOT_in_subscript6843); if (state.failed) return retval; + if ( state.backtracking==0 ) { + d1_tree = (PythonTree)adaptor.create(d1); + adaptor.addChild(root_0, d1_tree); + } + DOT252=(Token)match(input,DOT,FOLLOW_DOT_in_subscript6845); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOT252_tree = (PythonTree)adaptor.create(DOT252); + adaptor.addChild(root_0, DOT252_tree); + } + DOT253=(Token)match(input,DOT,FOLLOW_DOT_in_subscript6847); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOT253_tree = (PythonTree)adaptor.create(DOT253); + adaptor.addChild(root_0, DOT253_tree); + } + if ( state.backtracking==0 ) { + + retval.sltype = new Ellipsis(d1); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1916:7: ( test[null] COLON )=>lower= test[expr_contextType.Load] (c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_subscript6877); + lower=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, lower.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:41: (c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? )? + int alt126=2; + int LA126_0 = input.LA(1); + + if ( (LA126_0==COLON) ) { + alt126=1; + } + switch (alt126) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:42: c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? + { + c1=(Token)match(input,COLON,FOLLOW_COLON_in_subscript6883); if (state.failed) return retval; + if ( state.backtracking==0 ) { + c1_tree = (PythonTree)adaptor.create(c1); + adaptor.addChild(root_0, c1_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:51: (upper1= test[expr_contextType.Load] )? + int alt124=2; + int LA124_0 = input.LA(1); + + if ( (LA124_0==NAME||LA124_0==NOT||LA124_0==LPAREN||(LA124_0>=PLUS && LA124_0<=MINUS)||(LA124_0>=TILDE && LA124_0<=LBRACK)||LA124_0==LCURLY||LA124_0==BACKQUOTE) ) { + alt124=1; + } + else if ( (LA124_0==PRINT) && ((printFunction))) { + alt124=1; + } + else if ( (LA124_0==LAMBDA||(LA124_0>=INT && LA124_0<=STRING)) ) { + alt124=1; + } + switch (alt124) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:52: upper1= test[expr_contextType.Load] + { + pushFollow(FOLLOW_test_in_subscript6888); + upper1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, upper1.getTree()); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:89: ( sliceop )? + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==COLON) ) { + alt125=1; + } + switch (alt125) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1917:90: sliceop + { + pushFollow(FOLLOW_sliceop_in_subscript6894); + sliceop254=sliceop(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, sliceop254.getTree()); + + } + break; + + } + + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.sltype = actions.makeSubscript((lower!=null?((PythonTree)lower.tree):null), c1, (upper1!=null?((PythonTree)upper1.tree):null), (sliceop254!=null?((PythonTree)sliceop254.tree):null)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1921:7: ( COLON )=>c2= COLON (upper2= test[expr_contextType.Load] )? ( sliceop )? + { + root_0 = (PythonTree)adaptor.nil(); + + c2=(Token)match(input,COLON,FOLLOW_COLON_in_subscript6925); if (state.failed) return retval; + if ( state.backtracking==0 ) { + c2_tree = (PythonTree)adaptor.create(c2); + adaptor.addChild(root_0, c2_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1922:16: (upper2= test[expr_contextType.Load] )? + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==NAME||LA127_0==NOT||LA127_0==LPAREN||(LA127_0>=PLUS && LA127_0<=MINUS)||(LA127_0>=TILDE && LA127_0<=LBRACK)||LA127_0==LCURLY||LA127_0==BACKQUOTE) ) { + alt127=1; + } + else if ( (LA127_0==PRINT) && ((printFunction))) { + alt127=1; + } + else if ( (LA127_0==LAMBDA||(LA127_0>=INT && LA127_0<=STRING)) ) { + alt127=1; + } + switch (alt127) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1922:17: upper2= test[expr_contextType.Load] + { + pushFollow(FOLLOW_test_in_subscript6930); + upper2=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, upper2.getTree()); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1922:54: ( sliceop )? + int alt128=2; + int LA128_0 = input.LA(1); + + if ( (LA128_0==COLON) ) { + alt128=1; + } + switch (alt128) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1922:55: sliceop + { + pushFollow(FOLLOW_sliceop_in_subscript6936); + sliceop255=sliceop(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, sliceop255.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.sltype = actions.makeSubscript(null, c2, (upper2!=null?((PythonTree)upper2.tree):null), (sliceop255!=null?((PythonTree)sliceop255.tree):null)); + + } + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1926:7: test[expr_contextType.Load] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_subscript6954); + test256=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test256.getTree()); + if ( state.backtracking==0 ) { + + retval.sltype = new Index((test256!=null?((Token)test256.start):null), actions.castExpr((test256!=null?((PythonTree)test256.tree):null))); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = retval.sltype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "subscript" + + public static class sliceop_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "sliceop" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1933:1: sliceop : COLON ( test[expr_contextType.Load] -> test | ) ; + public final PythonParser.sliceop_return sliceop() throws RecognitionException { + PythonParser.sliceop_return retval = new PythonParser.sliceop_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COLON257=null; + PythonParser.test_return test258 = null; + + + PythonTree COLON257_tree=null; + RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); + RewriteRuleSubtreeStream stream_test=new RewriteRuleSubtreeStream(adaptor,"rule test"); + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1942:5: ( COLON ( test[expr_contextType.Load] -> test | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1942:7: COLON ( test[expr_contextType.Load] -> test | ) + { + COLON257=(Token)match(input,COLON,FOLLOW_COLON_in_sliceop6991); if (state.failed) return retval; + if ( state.backtracking==0 ) stream_COLON.add(COLON257); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1943:6: ( test[expr_contextType.Load] -> test | ) + int alt130=2; + int LA130_0 = input.LA(1); + + if ( (LA130_0==NAME||LA130_0==NOT||LA130_0==LPAREN||(LA130_0>=PLUS && LA130_0<=MINUS)||(LA130_0>=TILDE && LA130_0<=LBRACK)||LA130_0==LCURLY||LA130_0==BACKQUOTE) ) { + alt130=1; + } + else if ( (LA130_0==PRINT) && ((printFunction))) { + alt130=1; + } + else if ( (LA130_0==LAMBDA||(LA130_0>=INT && LA130_0<=STRING)) ) { + alt130=1; + } + else if ( (LA130_0==COMMA||LA130_0==RBRACK) ) { + alt130=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 130, 0, input); + + throw nvae; + } + switch (alt130) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1943:7: test[expr_contextType.Load] + { + pushFollow(FOLLOW_test_in_sliceop6999); + test258=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) stream_test.add(test258.getTree()); + + + // AST REWRITE + // elements: test + // token labels: + // rule labels: retval + // token list labels: + // rule list labels: + // wildcard labels: + if ( state.backtracking==0 ) { + retval.tree = root_0; + RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); + + root_0 = (PythonTree)adaptor.nil(); + // 1944:5: -> test + { + adaptor.addChild(root_0, stream_test.nextTree()); + + } + + retval.tree = root_0;} + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1946:8: + { + if ( state.backtracking==0 ) { + + etype = new Name(COLON257, "None", expr_contextType.Load); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "sliceop" + + public static class exprlist_return extends ParserRuleReturnScope { + public expr etype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "exprlist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1953:1: exprlist[expr_contextType ctype] returns [expr etype] : ( ( expr[null] COMMA )=>e+= expr[ctype] ( options {k=2; } : COMMA e+= expr[ctype] )* ( COMMA )? | expr[ctype] ); + public final PythonParser.exprlist_return exprlist(expr_contextType ctype) throws RecognitionException { + PythonParser.exprlist_return retval = new PythonParser.exprlist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA259=null; + Token COMMA260=null; + List list_e=null; + PythonParser.expr_return expr261 = null; + + PythonParser.expr_return e = null; + e = null; + PythonTree COMMA259_tree=null; + PythonTree COMMA260_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:5: ( ( expr[null] COMMA )=>e+= expr[ctype] ( options {k=2; } : COMMA e+= expr[ctype] )* ( COMMA )? | expr[ctype] ) + int alt133=2; + alt133 = dfa133.predict(input); + switch (alt133) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:7: ( expr[null] COMMA )=>e+= expr[ctype] ( options {k=2; } : COMMA e+= expr[ctype] )* ( COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_expr_in_exprlist7070); + e=expr(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree()); + if (list_e==null) list_e=new ArrayList(); + list_e.add(e.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:44: ( options {k=2; } : COMMA e+= expr[ctype] )* + loop131: + do { + int alt131=2; + alt131 = dfa131.predict(input); + switch (alt131) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:61: COMMA e+= expr[ctype] + { + COMMA259=(Token)match(input,COMMA,FOLLOW_COMMA_in_exprlist7082); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA259_tree = (PythonTree)adaptor.create(COMMA259); + adaptor.addChild(root_0, COMMA259_tree); + } + pushFollow(FOLLOW_expr_in_exprlist7086); + e=expr(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree()); + if (list_e==null) list_e=new ArrayList(); + list_e.add(e.getTree()); + + + } + break; + + default : + break loop131; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:84: ( COMMA )? + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==COMMA) ) { + alt132=1; + } + switch (alt132) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:85: COMMA + { + COMMA260=(Token)match(input,COMMA,FOLLOW_COMMA_in_exprlist7092); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA260_tree = (PythonTree)adaptor.create(COMMA260); + adaptor.addChild(root_0, COMMA260_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.etype = new Tuple(((Token)retval.start), actions.castExprs(list_e), ctype); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1959:7: expr[ctype] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_expr_in_exprlist7111); + expr261=expr(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, expr261.getTree()); + if ( state.backtracking==0 ) { + + retval.etype = actions.castExpr((expr261!=null?((PythonTree)expr261.tree):null)); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "exprlist" + + public static class del_list_return extends ParserRuleReturnScope { + public List etypes; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "del_list" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1967:1: del_list returns [List etypes] : e+= expr[expr_contextType.Del] ( options {k=2; } : COMMA e+= expr[expr_contextType.Del] )* ( COMMA )? ; + public final PythonParser.del_list_return del_list() throws RecognitionException { + PythonParser.del_list_return retval = new PythonParser.del_list_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA262=null; + Token COMMA263=null; + List list_e=null; + PythonParser.expr_return e = null; + e = null; + PythonTree COMMA262_tree=null; + PythonTree COMMA263_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:5: (e+= expr[expr_contextType.Del] ( options {k=2; } : COMMA e+= expr[expr_contextType.Del] )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:7: e+= expr[expr_contextType.Del] ( options {k=2; } : COMMA e+= expr[expr_contextType.Del] )* ( COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_expr_in_del_list7149); + e=expr(expr_contextType.Del); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree()); + if (list_e==null) list_e=new ArrayList(); + list_e.add(e.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:37: ( options {k=2; } : COMMA e+= expr[expr_contextType.Del] )* + loop134: + do { + int alt134=2; + alt134 = dfa134.predict(input); + switch (alt134) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:54: COMMA e+= expr[expr_contextType.Del] + { + COMMA262=(Token)match(input,COMMA,FOLLOW_COMMA_in_del_list7161); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA262_tree = (PythonTree)adaptor.create(COMMA262); + adaptor.addChild(root_0, COMMA262_tree); + } + pushFollow(FOLLOW_expr_in_del_list7165); + e=expr(expr_contextType.Del); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree()); + if (list_e==null) list_e=new ArrayList(); + list_e.add(e.getTree()); + + + } + break; + + default : + break loop134; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:92: ( COMMA )? + int alt135=2; + int LA135_0 = input.LA(1); + + if ( (LA135_0==COMMA) ) { + alt135=1; + } + switch (alt135) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1969:93: COMMA + { + COMMA263=(Token)match(input,COMMA,FOLLOW_COMMA_in_del_list7171); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA263_tree = (PythonTree)adaptor.create(COMMA263); + adaptor.addChild(root_0, COMMA263_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.etypes = actions.makeDeleteList(list_e); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "del_list" + + public static class testlist_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "testlist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1976:1: testlist[expr_contextType ctype] : ( ( test[null] COMMA )=>t+= test[ctype] ( options {k=2; } : COMMA t+= test[ctype] )* ( COMMA )? | test[ctype] ); + public final PythonParser.testlist_return testlist(expr_contextType ctype) throws RecognitionException { + PythonParser.testlist_return retval = new PythonParser.testlist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA264=null; + Token COMMA265=null; + List list_t=null; + PythonParser.test_return test266 = null; + + PythonParser.test_return t = null; + t = null; + PythonTree COMMA264_tree=null; + PythonTree COMMA265_tree=null; + + + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1985:5: ( ( test[null] COMMA )=>t+= test[ctype] ( options {k=2; } : COMMA t+= test[ctype] )* ( COMMA )? | test[ctype] ) + int alt138=2; + alt138 = dfa138.predict(input); + switch (alt138) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1985:7: ( test[null] COMMA )=>t+= test[ctype] ( options {k=2; } : COMMA t+= test[ctype] )* ( COMMA )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_testlist7224); + t=test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1986:22: ( options {k=2; } : COMMA t+= test[ctype] )* + loop136: + do { + int alt136=2; + alt136 = dfa136.predict(input); + switch (alt136) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1986:39: COMMA t+= test[ctype] + { + COMMA264=(Token)match(input,COMMA,FOLLOW_COMMA_in_testlist7236); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA264_tree = (PythonTree)adaptor.create(COMMA264); + adaptor.addChild(root_0, COMMA264_tree); + } + pushFollow(FOLLOW_test_in_testlist7240); + t=test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree()); + if (list_t==null) list_t=new ArrayList(); + list_t.add(t.getTree()); + + + } + break; + + default : + break loop136; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1986:62: ( COMMA )? + int alt137=2; + int LA137_0 = input.LA(1); + + if ( (LA137_0==COMMA) ) { + alt137=1; + } + switch (alt137) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1986:63: COMMA + { + COMMA265=(Token)match(input,COMMA,FOLLOW_COMMA_in_testlist7246); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA265_tree = (PythonTree)adaptor.create(COMMA265); + adaptor.addChild(root_0, COMMA265_tree); + } + + } + break; + + } + + if ( state.backtracking==0 ) { + + etype = new Tuple(((Token)retval.start), actions.castExprs(list_t), ctype); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1990:7: test[ctype] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_testlist7264); + test266=test(ctype); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test266.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "testlist" + + public static class dictorsetmaker_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "dictorsetmaker" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1995:1: dictorsetmaker[Token lcurly] : k+= test[expr_contextType.Load] ( ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) ( COMMA )? | comp_for[gens] ) ; + public final PythonParser.dictorsetmaker_return dictorsetmaker(Token lcurly) throws RecognitionException { + PythonParser.dictorsetmaker_return retval = new PythonParser.dictorsetmaker_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COLON267=null; + Token COMMA269=null; + Token COLON270=null; + Token COMMA271=null; + Token COMMA272=null; + List list_k=null; + List list_v=null; + PythonParser.comp_for_return comp_for268 = null; + + PythonParser.comp_for_return comp_for273 = null; + + PythonParser.test_return k = null; + k = null; + PythonParser.test_return v = null; + v = null; + PythonTree COLON267_tree=null; + PythonTree COMMA269_tree=null; + PythonTree COLON270_tree=null; + PythonTree COMMA271_tree=null; + PythonTree COMMA272_tree=null; + + + List gens = new ArrayList(); + expr etype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2005:5: (k+= test[expr_contextType.Load] ( ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) ( COMMA )? | comp_for[gens] ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2005:7: k+= test[expr_contextType.Load] ( ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) ( COMMA )? | comp_for[gens] ) + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_dictorsetmaker7297); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + if (list_k==null) list_k=new ArrayList(); + list_k.add(k.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2006:10: ( ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) ( COMMA )? | comp_for[gens] ) + int alt144=2; + int LA144_0 = input.LA(1); + + if ( (LA144_0==COLON||LA144_0==COMMA||LA144_0==RCURLY) ) { + alt144=1; + } + else if ( (LA144_0==FOR) ) { + alt144=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 144, 0, input); + + throw nvae; + } + switch (alt144) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2007:14: ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) ( COMMA )? + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2007:14: ( COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) | ( COMMA k+= test[expr_contextType.Load] )* ) + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==COLON) ) { + alt142=1; + } + else if ( (LA142_0==COMMA||LA142_0==RCURLY) ) { + alt142=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 142, 0, input); + + throw nvae; + } + switch (alt142) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2007:15: COLON v+= test[expr_contextType.Load] ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) + { + COLON267=(Token)match(input,COLON,FOLLOW_COLON_in_dictorsetmaker7325); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON267_tree = (PythonTree)adaptor.create(COLON267); + adaptor.addChild(root_0, COLON267_tree); + } + pushFollow(FOLLOW_test_in_dictorsetmaker7329); + v=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, v.getTree()); + if (list_v==null) list_v=new ArrayList(); + list_v.add(v.getTree()); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2008:16: ( comp_for[gens] | ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* ) + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==FOR) ) { + alt140=1; + } + else if ( (LA140_0==COMMA||LA140_0==RCURLY) ) { + alt140=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 140, 0, input); + + throw nvae; + } + switch (alt140) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2008:18: comp_for[gens] + { + pushFollow(FOLLOW_comp_for_in_dictorsetmaker7349); + comp_for268=comp_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_for268.getTree()); + if ( state.backtracking==0 ) { + + Collections.reverse(gens); + List c = gens; + etype = new DictComp(((Token)retval.start), actions.castExpr(list_k.get(0)), actions.castExpr(list_v.get(0)), c); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2014:18: ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2014:18: ( options {k=2; } : COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] )* + loop139: + do { + int alt139=2; + alt139 = dfa139.predict(input); + switch (alt139) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2014:34: COMMA k+= test[expr_contextType.Load] COLON v+= test[expr_contextType.Load] + { + COMMA269=(Token)match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker7396); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA269_tree = (PythonTree)adaptor.create(COMMA269); + adaptor.addChild(root_0, COMMA269_tree); + } + pushFollow(FOLLOW_test_in_dictorsetmaker7400); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + if (list_k==null) list_k=new ArrayList(); + list_k.add(k.getTree()); + + COLON270=(Token)match(input,COLON,FOLLOW_COLON_in_dictorsetmaker7403); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON270_tree = (PythonTree)adaptor.create(COLON270); + adaptor.addChild(root_0, COLON270_tree); + } + pushFollow(FOLLOW_test_in_dictorsetmaker7407); + v=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, v.getTree()); + if (list_v==null) list_v=new ArrayList(); + list_v.add(v.getTree()); + + + } + break; + + default : + break loop139; + } + } while (true); + + if ( state.backtracking==0 ) { + + etype = new Dict(lcurly, actions.castExprs(list_k), actions.castExprs(list_v)); + + } + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2019:15: ( COMMA k+= test[expr_contextType.Load] )* + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2019:15: ( COMMA k+= test[expr_contextType.Load] )* + loop141: + do { + int alt141=2; + int LA141_0 = input.LA(1); + + if ( (LA141_0==COMMA) ) { + int LA141_1 = input.LA(2); + + if ( (LA141_1==NAME||LA141_1==PRINT||(LA141_1>=LAMBDA && LA141_1<=NOT)||LA141_1==LPAREN||(LA141_1>=PLUS && LA141_1<=MINUS)||(LA141_1>=TILDE && LA141_1<=LBRACK)||LA141_1==LCURLY||(LA141_1>=BACKQUOTE && LA141_1<=STRING)) ) { + alt141=1; + } + + + } + + + switch (alt141) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2019:16: COMMA k+= test[expr_contextType.Load] + { + COMMA271=(Token)match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker7463); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA271_tree = (PythonTree)adaptor.create(COMMA271); + adaptor.addChild(root_0, COMMA271_tree); + } + pushFollow(FOLLOW_test_in_dictorsetmaker7467); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + if (list_k==null) list_k=new ArrayList(); + list_k.add(k.getTree()); + + + } + break; + + default : + break loop141; + } + } while (true); + + if ( state.backtracking==0 ) { + + etype = new Set(lcurly, actions.castExprs(list_k)); + + } + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2024:14: ( COMMA )? + int alt143=2; + int LA143_0 = input.LA(1); + + if ( (LA143_0==COMMA) ) { + alt143=1; + } + switch (alt143) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2024:15: COMMA + { + COMMA272=(Token)match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker7517); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA272_tree = (PythonTree)adaptor.create(COMMA272); + adaptor.addChild(root_0, COMMA272_tree); + } + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2025:12: comp_for[gens] + { + pushFollow(FOLLOW_comp_for_in_dictorsetmaker7532); + comp_for273=comp_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_for273.getTree()); + if ( state.backtracking==0 ) { + + Collections.reverse(gens); + List c = gens; + expr e = actions.castExpr(list_k.get(0)); + if (e instanceof Context) { + ((Context)e).setContext(expr_contextType.Load); + } + etype = new SetComp(lcurly, actions.castExpr(list_k.get(0)), c); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + if (etype != null) { + retval.tree = etype; + } + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "dictorsetmaker" + + public static class classdef_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "classdef" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2039:1: classdef : ( decorators )? CLASS NAME ( LPAREN ( testlist[expr_contextType.Load] )? RPAREN )? COLON suite[false] ; + public final PythonParser.classdef_return classdef() throws RecognitionException { + PythonParser.classdef_return retval = new PythonParser.classdef_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token CLASS275=null; + Token NAME276=null; + Token LPAREN277=null; + Token RPAREN279=null; + Token COLON280=null; + PythonParser.decorators_return decorators274 = null; + + PythonParser.testlist_return testlist278 = null; + + PythonParser.suite_return suite281 = null; + + + PythonTree CLASS275_tree=null; + PythonTree NAME276_tree=null; + PythonTree LPAREN277_tree=null; + PythonTree RPAREN279_tree=null; + PythonTree COLON280_tree=null; + + + stmt stype = null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:5: ( ( decorators )? CLASS NAME ( LPAREN ( testlist[expr_contextType.Load] )? RPAREN )? COLON suite[false] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:7: ( decorators )? CLASS NAME ( LPAREN ( testlist[expr_contextType.Load] )? RPAREN )? COLON suite[false] + { + root_0 = (PythonTree)adaptor.nil(); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:7: ( decorators )? + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==AT) ) { + alt145=1; + } + switch (alt145) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:7: decorators + { + pushFollow(FOLLOW_decorators_in_classdef7585); + decorators274=decorators(); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, decorators274.getTree()); + + } + break; + + } + + CLASS275=(Token)match(input,CLASS,FOLLOW_CLASS_in_classdef7588); if (state.failed) return retval; + if ( state.backtracking==0 ) { + CLASS275_tree = (PythonTree)adaptor.create(CLASS275); + adaptor.addChild(root_0, CLASS275_tree); + } + NAME276=(Token)match(input,NAME,FOLLOW_NAME_in_classdef7590); if (state.failed) return retval; + if ( state.backtracking==0 ) { + NAME276_tree = (PythonTree)adaptor.create(NAME276); + adaptor.addChild(root_0, NAME276_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:30: ( LPAREN ( testlist[expr_contextType.Load] )? RPAREN )? + int alt147=2; + int LA147_0 = input.LA(1); + + if ( (LA147_0==LPAREN) ) { + alt147=1; + } + switch (alt147) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:31: LPAREN ( testlist[expr_contextType.Load] )? RPAREN + { + LPAREN277=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_classdef7593); if (state.failed) return retval; + if ( state.backtracking==0 ) { + LPAREN277_tree = (PythonTree)adaptor.create(LPAREN277); + adaptor.addChild(root_0, LPAREN277_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:38: ( testlist[expr_contextType.Load] )? + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==NAME||LA146_0==NOT||LA146_0==LPAREN||(LA146_0>=PLUS && LA146_0<=MINUS)||(LA146_0>=TILDE && LA146_0<=LBRACK)||LA146_0==LCURLY||LA146_0==BACKQUOTE) ) { + alt146=1; + } + else if ( (LA146_0==PRINT) && ((printFunction))) { + alt146=1; + } + else if ( (LA146_0==LAMBDA||(LA146_0>=INT && LA146_0<=STRING)) ) { + alt146=1; + } + switch (alt146) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2046:38: testlist[expr_contextType.Load] + { + pushFollow(FOLLOW_testlist_in_classdef7595); + testlist278=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist278.getTree()); + + } + break; + + } + + RPAREN279=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_classdef7599); if (state.failed) return retval; + if ( state.backtracking==0 ) { + RPAREN279_tree = (PythonTree)adaptor.create(RPAREN279); + adaptor.addChild(root_0, RPAREN279_tree); + } + + } + break; + + } + + COLON280=(Token)match(input,COLON,FOLLOW_COLON_in_classdef7603); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COLON280_tree = (PythonTree)adaptor.create(COLON280); + adaptor.addChild(root_0, COLON280_tree); + } + pushFollow(FOLLOW_suite_in_classdef7605); + suite281=suite(false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, suite281.getTree()); + if ( state.backtracking==0 ) { + + Token t = CLASS275; + if ((decorators274!=null?((Token)decorators274.start):null) != null) { + t = (decorators274!=null?((Token)decorators274.start):null); + } + stype = new ClassDef(t, actions.cantBeNoneName(NAME276), + actions.makeBases(actions.castExpr((testlist278!=null?((PythonTree)testlist278.tree):null))), + actions.castStmts((suite281!=null?suite281.stypes:null)), + actions.castExprs((decorators274!=null?decorators274.etypes:null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + retval.tree = stype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "classdef" + + public static class arglist_return extends ParserRuleReturnScope { + public List args; + public List keywords; + public expr starargs; + public expr kwargs; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "arglist" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2062:1: arglist returns [List args, List keywords, expr starargs, expr kwargs] : ( argument[arguments, kws, gens, true, false] ( COMMA argument[arguments, kws, gens, false, false] )* ( COMMA ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? )? | STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] ); + public final PythonParser.arglist_return arglist() throws RecognitionException { + PythonParser.arglist_return retval = new PythonParser.arglist_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token COMMA283=null; + Token COMMA285=null; + Token STAR286=null; + Token COMMA287=null; + Token COMMA289=null; + Token DOUBLESTAR290=null; + Token DOUBLESTAR291=null; + Token STAR292=null; + Token COMMA293=null; + Token COMMA295=null; + Token DOUBLESTAR296=null; + Token DOUBLESTAR297=null; + PythonParser.test_return s = null; + + PythonParser.test_return k = null; + + PythonParser.argument_return argument282 = null; + + PythonParser.argument_return argument284 = null; + + PythonParser.argument_return argument288 = null; + + PythonParser.argument_return argument294 = null; + + + PythonTree COMMA283_tree=null; + PythonTree COMMA285_tree=null; + PythonTree STAR286_tree=null; + PythonTree COMMA287_tree=null; + PythonTree COMMA289_tree=null; + PythonTree DOUBLESTAR290_tree=null; + PythonTree DOUBLESTAR291_tree=null; + PythonTree STAR292_tree=null; + PythonTree COMMA293_tree=null; + PythonTree COMMA295_tree=null; + PythonTree DOUBLESTAR296_tree=null; + PythonTree DOUBLESTAR297_tree=null; + + + List arguments = new ArrayList(); + List kws = new ArrayList(); + List gens = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2069:5: ( argument[arguments, kws, gens, true, false] ( COMMA argument[arguments, kws, gens, false, false] )* ( COMMA ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? )? | STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] ) + int alt155=3; + int LA155_0 = input.LA(1); + + if ( (LA155_0==NAME||LA155_0==NOT||LA155_0==LPAREN||(LA155_0>=PLUS && LA155_0<=MINUS)||(LA155_0>=TILDE && LA155_0<=LBRACK)||LA155_0==LCURLY||LA155_0==BACKQUOTE) ) { + alt155=1; + } + else if ( (LA155_0==PRINT) && ((printFunction))) { + alt155=1; + } + else if ( (LA155_0==LAMBDA||(LA155_0>=INT && LA155_0<=STRING)) ) { + alt155=1; + } + else if ( (LA155_0==STAR) ) { + alt155=2; + } + else if ( (LA155_0==DOUBLESTAR) ) { + alt155=3; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 155, 0, input); + + throw nvae; + } + switch (alt155) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2069:7: argument[arguments, kws, gens, true, false] ( COMMA argument[arguments, kws, gens, false, false] )* ( COMMA ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? )? + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_argument_in_arglist7647); + argument282=argument(arguments, kws, gens, true, false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, argument282.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2069:51: ( COMMA argument[arguments, kws, gens, false, false] )* + loop148: + do { + int alt148=2; + int LA148_0 = input.LA(1); + + if ( (LA148_0==COMMA) ) { + int LA148_1 = input.LA(2); + + if ( (LA148_1==NAME||LA148_1==PRINT||(LA148_1>=LAMBDA && LA148_1<=NOT)||LA148_1==LPAREN||(LA148_1>=PLUS && LA148_1<=MINUS)||(LA148_1>=TILDE && LA148_1<=LBRACK)||LA148_1==LCURLY||(LA148_1>=BACKQUOTE && LA148_1<=STRING)) ) { + alt148=1; + } + + + } + + + switch (alt148) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2069:52: COMMA argument[arguments, kws, gens, false, false] + { + COMMA283=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7651); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA283_tree = (PythonTree)adaptor.create(COMMA283); + adaptor.addChild(root_0, COMMA283_tree); + } + pushFollow(FOLLOW_argument_in_arglist7653); + argument284=argument(arguments, kws, gens, false, false); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, argument284.getTree()); + + } + break; + + default : + break loop148; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2070:11: ( COMMA ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? )? + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==COMMA) ) { + alt152=1; + } + switch (alt152) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2070:12: COMMA ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? + { + COMMA285=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7669); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA285_tree = (PythonTree)adaptor.create(COMMA285); + adaptor.addChild(root_0, COMMA285_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:15: ( STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? | DOUBLESTAR k= test[expr_contextType.Load] )? + int alt151=3; + int LA151_0 = input.LA(1); + + if ( (LA151_0==STAR) ) { + alt151=1; + } + else if ( (LA151_0==DOUBLESTAR) ) { + alt151=2; + } + switch (alt151) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:17: STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? + { + STAR286=(Token)match(input,STAR,FOLLOW_STAR_in_arglist7687); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR286_tree = (PythonTree)adaptor.create(STAR286); + adaptor.addChild(root_0, STAR286_tree); + } + pushFollow(FOLLOW_test_in_arglist7691); + s=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:52: ( COMMA argument[arguments, kws, gens, false, true] )* + loop149: + do { + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==COMMA) ) { + int LA149_1 = input.LA(2); + + if ( (LA149_1==NAME||LA149_1==PRINT||(LA149_1>=LAMBDA && LA149_1<=NOT)||LA149_1==LPAREN||(LA149_1>=PLUS && LA149_1<=MINUS)||(LA149_1>=TILDE && LA149_1<=LBRACK)||LA149_1==LCURLY||(LA149_1>=BACKQUOTE && LA149_1<=STRING)) ) { + alt149=1; + } + + + } + + + switch (alt149) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:53: COMMA argument[arguments, kws, gens, false, true] + { + COMMA287=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7695); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA287_tree = (PythonTree)adaptor.create(COMMA287); + adaptor.addChild(root_0, COMMA287_tree); + } + pushFollow(FOLLOW_argument_in_arglist7697); + argument288=argument(arguments, kws, gens, false, true); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, argument288.getTree()); + + } + break; + + default : + break loop149; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:105: ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==COMMA) ) { + alt150=1; + } + switch (alt150) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2071:106: COMMA DOUBLESTAR k= test[expr_contextType.Load] + { + COMMA289=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7703); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA289_tree = (PythonTree)adaptor.create(COMMA289); + adaptor.addChild(root_0, COMMA289_tree); + } + DOUBLESTAR290=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist7705); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR290_tree = (PythonTree)adaptor.create(DOUBLESTAR290); + adaptor.addChild(root_0, DOUBLESTAR290_tree); + } + pushFollow(FOLLOW_test_in_arglist7709); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2072:17: DOUBLESTAR k= test[expr_contextType.Load] + { + DOUBLESTAR291=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist7730); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR291_tree = (PythonTree)adaptor.create(DOUBLESTAR291); + adaptor.addChild(root_0, DOUBLESTAR291_tree); + } + pushFollow(FOLLOW_test_in_arglist7734); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + + } + break; + + } + + + } + break; + + } + + if ( state.backtracking==0 ) { + + if (arguments.size() > 1 && gens.size() > 0) { + actions.errorGenExpNotSoleArg(new PythonTree(((Token)retval.start))); + } + retval.args =arguments; + retval.keywords =kws; + retval.starargs =actions.castExpr((s!=null?((PythonTree)s.tree):null)); + retval.kwargs =actions.castExpr((k!=null?((PythonTree)k.tree):null)); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2084:7: STAR s= test[expr_contextType.Load] ( COMMA argument[arguments, kws, gens, false, true] )* ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? + { + root_0 = (PythonTree)adaptor.nil(); + + STAR292=(Token)match(input,STAR,FOLLOW_STAR_in_arglist7781); if (state.failed) return retval; + if ( state.backtracking==0 ) { + STAR292_tree = (PythonTree)adaptor.create(STAR292); + adaptor.addChild(root_0, STAR292_tree); + } + pushFollow(FOLLOW_test_in_arglist7785); + s=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2084:42: ( COMMA argument[arguments, kws, gens, false, true] )* + loop153: + do { + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==COMMA) ) { + int LA153_1 = input.LA(2); + + if ( (LA153_1==NAME||LA153_1==PRINT||(LA153_1>=LAMBDA && LA153_1<=NOT)||LA153_1==LPAREN||(LA153_1>=PLUS && LA153_1<=MINUS)||(LA153_1>=TILDE && LA153_1<=LBRACK)||LA153_1==LCURLY||(LA153_1>=BACKQUOTE && LA153_1<=STRING)) ) { + alt153=1; + } + + + } + + + switch (alt153) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2084:43: COMMA argument[arguments, kws, gens, false, true] + { + COMMA293=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7789); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA293_tree = (PythonTree)adaptor.create(COMMA293); + adaptor.addChild(root_0, COMMA293_tree); + } + pushFollow(FOLLOW_argument_in_arglist7791); + argument294=argument(arguments, kws, gens, false, true); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, argument294.getTree()); + + } + break; + + default : + break loop153; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2084:95: ( COMMA DOUBLESTAR k= test[expr_contextType.Load] )? + int alt154=2; + int LA154_0 = input.LA(1); + + if ( (LA154_0==COMMA) ) { + alt154=1; + } + switch (alt154) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2084:96: COMMA DOUBLESTAR k= test[expr_contextType.Load] + { + COMMA295=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist7797); if (state.failed) return retval; + if ( state.backtracking==0 ) { + COMMA295_tree = (PythonTree)adaptor.create(COMMA295); + adaptor.addChild(root_0, COMMA295_tree); + } + DOUBLESTAR296=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist7799); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR296_tree = (PythonTree)adaptor.create(DOUBLESTAR296); + adaptor.addChild(root_0, DOUBLESTAR296_tree); + } + pushFollow(FOLLOW_test_in_arglist7803); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.starargs =actions.castExpr((s!=null?((PythonTree)s.tree):null)); + retval.keywords =kws; + retval.kwargs =actions.castExpr((k!=null?((PythonTree)k.tree):null)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2090:7: DOUBLESTAR k= test[expr_contextType.Load] + { + root_0 = (PythonTree)adaptor.nil(); + + DOUBLESTAR297=(Token)match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist7822); if (state.failed) return retval; + if ( state.backtracking==0 ) { + DOUBLESTAR297_tree = (PythonTree)adaptor.create(DOUBLESTAR297); + adaptor.addChild(root_0, DOUBLESTAR297_tree); + } + pushFollow(FOLLOW_test_in_arglist7826); + k=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, k.getTree()); + if ( state.backtracking==0 ) { + + retval.kwargs =actions.castExpr((k!=null?((PythonTree)k.tree):null)); + + } + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "arglist" + + public static class argument_return extends ParserRuleReturnScope { + public boolean genarg; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "argument" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2097:1: argument[List arguments, List kws, List gens, boolean first, boolean afterStar] returns [boolean genarg] : t1= test[expr_contextType.Load] ( ( ASSIGN t2= test[expr_contextType.Load] ) | comp_for[$gens] | ) ; + public final PythonParser.argument_return argument(List arguments, List kws, List gens, boolean first, boolean afterStar) throws RecognitionException { + PythonParser.argument_return retval = new PythonParser.argument_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token ASSIGN298=null; + PythonParser.test_return t1 = null; + + PythonParser.test_return t2 = null; + + PythonParser.comp_for_return comp_for299 = null; + + + PythonTree ASSIGN298_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2099:5: (t1= test[expr_contextType.Load] ( ( ASSIGN t2= test[expr_contextType.Load] ) | comp_for[$gens] | ) ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2099:7: t1= test[expr_contextType.Load] ( ( ASSIGN t2= test[expr_contextType.Load] ) | comp_for[$gens] | ) + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_test_in_argument7865); + t1=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2100:9: ( ( ASSIGN t2= test[expr_contextType.Load] ) | comp_for[$gens] | ) + int alt156=3; + switch ( input.LA(1) ) { + case ASSIGN: + { + alt156=1; + } + break; + case FOR: + { + alt156=2; + } + break; + case RPAREN: + case COMMA: + { + alt156=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 156, 0, input); + + throw nvae; + } + + switch (alt156) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2100:10: ( ASSIGN t2= test[expr_contextType.Load] ) + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2100:10: ( ASSIGN t2= test[expr_contextType.Load] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2100:11: ASSIGN t2= test[expr_contextType.Load] + { + ASSIGN298=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_argument7878); if (state.failed) return retval; + if ( state.backtracking==0 ) { + ASSIGN298_tree = (PythonTree)adaptor.create(ASSIGN298); + adaptor.addChild(root_0, ASSIGN298_tree); + } + pushFollow(FOLLOW_test_in_argument7882); + t2=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree()); + + } + + if ( state.backtracking==0 ) { + + expr newkey = actions.castExpr((t1!=null?((PythonTree)t1.tree):null)); + //Loop through all current keys and fail on duplicate. + for(Object o: kws) { + List list = (List)o; + Object oldkey = list.get(0); + if (oldkey instanceof Name && newkey instanceof Name) { + if (((Name)oldkey).getId().equals(((Name)newkey).getId())) { + errorHandler.error("keyword arguments repeated", (t1!=null?((PythonTree)t1.tree):null)); + } + } + } + List exprs = new ArrayList(); + exprs.add(newkey); + exprs.add(actions.castExpr((t2!=null?((PythonTree)t2.tree):null))); + kws.add(exprs); + + } + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2118:11: comp_for[$gens] + { + pushFollow(FOLLOW_comp_for_in_argument7908); + comp_for299=comp_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_for299.getTree()); + if ( state.backtracking==0 ) { + + if (!first) { + actions.errorGenExpNotSoleArg((comp_for299!=null?((PythonTree)comp_for299.tree):null)); + } + retval.genarg = true; + Collections.reverse(gens); + List c = gens; + arguments.add(new GeneratorExp((t1!=null?((Token)t1.start):null), actions.castExpr((t1!=null?((PythonTree)t1.tree):null)), c)); + + } + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2129:11: + { + if ( state.backtracking==0 ) { + + if (kws.size() > 0) { + errorHandler.error("non-keyword arg after keyword arg", (t1!=null?((PythonTree)t1.tree):null)); + } else if (afterStar) { + errorHandler.error("only named arguments may follow *expression", (t1!=null?((PythonTree)t1.tree):null)); + } + arguments.add((t1!=null?((PythonTree)t1.tree):null)); + + } + + } + break; + + } + + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "argument" + + public static class list_iter_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "list_iter" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2141:1: list_iter[List gens, List ifs] : ( list_for[gens] | list_if[gens, ifs] ); + public final PythonParser.list_iter_return list_iter(List gens, List ifs) throws RecognitionException { + PythonParser.list_iter_return retval = new PythonParser.list_iter_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.list_for_return list_for300 = null; + + PythonParser.list_if_return list_if301 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2142:5: ( list_for[gens] | list_if[gens, ifs] ) + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==FOR) ) { + alt157=1; + } + else if ( (LA157_0==IF) ) { + alt157=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 157, 0, input); + + throw nvae; + } + switch (alt157) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2142:7: list_for[gens] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_list_for_in_list_iter7973); + list_for300=list_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, list_for300.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2143:7: list_if[gens, ifs] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_list_if_in_list_iter7982); + list_if301=list_if(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, list_if301.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "list_iter" + + public static class list_for_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "list_for" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2147:1: list_for[List gens] : FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] ( list_iter[gens, ifs] )? ; + public final PythonParser.list_for_return list_for(List gens) throws RecognitionException { + PythonParser.list_for_return retval = new PythonParser.list_for_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token FOR302=null; + Token IN304=null; + PythonParser.exprlist_return exprlist303 = null; + + PythonParser.testlist_return testlist305 = null; + + PythonParser.list_iter_return list_iter306 = null; + + + PythonTree FOR302_tree=null; + PythonTree IN304_tree=null; + + + List ifs = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2151:5: ( FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] ( list_iter[gens, ifs] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2151:7: FOR exprlist[expr_contextType.Store] IN testlist[expr_contextType.Load] ( list_iter[gens, ifs] )? + { + root_0 = (PythonTree)adaptor.nil(); + + FOR302=(Token)match(input,FOR,FOLLOW_FOR_in_list_for8008); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FOR302_tree = (PythonTree)adaptor.create(FOR302); + adaptor.addChild(root_0, FOR302_tree); + } + pushFollow(FOLLOW_exprlist_in_list_for8010); + exprlist303=exprlist(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, exprlist303.getTree()); + IN304=(Token)match(input,IN,FOLLOW_IN_in_list_for8013); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN304_tree = (PythonTree)adaptor.create(IN304); + adaptor.addChild(root_0, IN304_tree); + } + pushFollow(FOLLOW_testlist_in_list_for8015); + testlist305=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist305.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2151:79: ( list_iter[gens, ifs] )? + int alt158=2; + int LA158_0 = input.LA(1); + + if ( (LA158_0==FOR||LA158_0==IF) ) { + alt158=1; + } + switch (alt158) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2151:80: list_iter[gens, ifs] + { + pushFollow(FOLLOW_list_iter_in_list_for8019); + list_iter306=list_iter(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, list_iter306.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + Collections.reverse(ifs); + gens.add(new comprehension(FOR302, (exprlist303!=null?exprlist303.etype:null), actions.castExpr((testlist305!=null?((PythonTree)testlist305.tree):null)), ifs)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "list_for" + + public static class list_if_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "list_if" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2159:1: list_if[List gens, List ifs] : IF test[expr_contextType.Load] ( list_iter[gens, ifs] )? ; + public final PythonParser.list_if_return list_if(List gens, List ifs) throws RecognitionException { + PythonParser.list_if_return retval = new PythonParser.list_if_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token IF307=null; + PythonParser.test_return test308 = null; + + PythonParser.list_iter_return list_iter309 = null; + + + PythonTree IF307_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2160:5: ( IF test[expr_contextType.Load] ( list_iter[gens, ifs] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2160:7: IF test[expr_contextType.Load] ( list_iter[gens, ifs] )? + { + root_0 = (PythonTree)adaptor.nil(); + + IF307=(Token)match(input,IF,FOLLOW_IF_in_list_if8049); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IF307_tree = (PythonTree)adaptor.create(IF307); + adaptor.addChild(root_0, IF307_tree); + } + pushFollow(FOLLOW_test_in_list_if8051); + test308=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test308.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2160:38: ( list_iter[gens, ifs] )? + int alt159=2; + int LA159_0 = input.LA(1); + + if ( (LA159_0==FOR||LA159_0==IF) ) { + alt159=1; + } + switch (alt159) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2160:39: list_iter[gens, ifs] + { + pushFollow(FOLLOW_list_iter_in_list_if8055); + list_iter309=list_iter(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, list_iter309.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + ifs.add(actions.castExpr((test308!=null?((PythonTree)test308.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "list_if" + + public static class comp_iter_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "comp_iter" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2167:1: comp_iter[List gens, List ifs] : ( comp_for[gens] | comp_if[gens, ifs] ); + public final PythonParser.comp_iter_return comp_iter(List gens, List ifs) throws RecognitionException { + PythonParser.comp_iter_return retval = new PythonParser.comp_iter_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + PythonParser.comp_for_return comp_for310 = null; + + PythonParser.comp_if_return comp_if311 = null; + + + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2168:5: ( comp_for[gens] | comp_if[gens, ifs] ) + int alt160=2; + int LA160_0 = input.LA(1); + + if ( (LA160_0==FOR) ) { + alt160=1; + } + else if ( (LA160_0==IF) ) { + alt160=2; + } + else { + if (state.backtracking>0) {state.failed=true; return retval;} + NoViableAltException nvae = + new NoViableAltException("", 160, 0, input); + + throw nvae; + } + switch (alt160) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2168:7: comp_for[gens] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_comp_for_in_comp_iter8086); + comp_for310=comp_for(gens); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_for310.getTree()); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2169:7: comp_if[gens, ifs] + { + root_0 = (PythonTree)adaptor.nil(); + + pushFollow(FOLLOW_comp_if_in_comp_iter8095); + comp_if311=comp_if(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_if311.getTree()); + + } + break; + + } + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "comp_iter" + + public static class comp_for_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "comp_for" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2173:1: comp_for[List gens] : FOR exprlist[expr_contextType.Store] IN or_test[expr_contextType.Load] ( comp_iter[gens, ifs] )? ; + public final PythonParser.comp_for_return comp_for(List gens) throws RecognitionException { + PythonParser.comp_for_return retval = new PythonParser.comp_for_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token FOR312=null; + Token IN314=null; + PythonParser.exprlist_return exprlist313 = null; + + PythonParser.or_test_return or_test315 = null; + + PythonParser.comp_iter_return comp_iter316 = null; + + + PythonTree FOR312_tree=null; + PythonTree IN314_tree=null; + + + List ifs = new ArrayList(); + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2177:5: ( FOR exprlist[expr_contextType.Store] IN or_test[expr_contextType.Load] ( comp_iter[gens, ifs] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2177:7: FOR exprlist[expr_contextType.Store] IN or_test[expr_contextType.Load] ( comp_iter[gens, ifs] )? + { + root_0 = (PythonTree)adaptor.nil(); + + FOR312=(Token)match(input,FOR,FOLLOW_FOR_in_comp_for8121); if (state.failed) return retval; + if ( state.backtracking==0 ) { + FOR312_tree = (PythonTree)adaptor.create(FOR312); + adaptor.addChild(root_0, FOR312_tree); + } + pushFollow(FOLLOW_exprlist_in_comp_for8123); + exprlist313=exprlist(expr_contextType.Store); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, exprlist313.getTree()); + IN314=(Token)match(input,IN,FOLLOW_IN_in_comp_for8126); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IN314_tree = (PythonTree)adaptor.create(IN314); + adaptor.addChild(root_0, IN314_tree); + } + pushFollow(FOLLOW_or_test_in_comp_for8128); + or_test315=or_test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, or_test315.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2177:78: ( comp_iter[gens, ifs] )? + int alt161=2; + int LA161_0 = input.LA(1); + + if ( (LA161_0==FOR||LA161_0==IF) ) { + alt161=1; + } + switch (alt161) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2177:78: comp_iter[gens, ifs] + { + pushFollow(FOLLOW_comp_iter_in_comp_for8131); + comp_iter316=comp_iter(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_iter316.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + Collections.reverse(ifs); + gens.add(new comprehension(FOR312, (exprlist313!=null?exprlist313.etype:null), actions.castExpr((or_test315!=null?((PythonTree)or_test315.tree):null)), ifs)); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "comp_for" + + public static class comp_if_return extends ParserRuleReturnScope { + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "comp_if" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2185:1: comp_if[List gens, List ifs] : IF test[expr_contextType.Load] ( comp_iter[gens, ifs] )? ; + public final PythonParser.comp_if_return comp_if(List gens, List ifs) throws RecognitionException { + PythonParser.comp_if_return retval = new PythonParser.comp_if_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token IF317=null; + PythonParser.test_return test318 = null; + + PythonParser.comp_iter_return comp_iter319 = null; + + + PythonTree IF317_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2186:5: ( IF test[expr_contextType.Load] ( comp_iter[gens, ifs] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2186:7: IF test[expr_contextType.Load] ( comp_iter[gens, ifs] )? + { + root_0 = (PythonTree)adaptor.nil(); + + IF317=(Token)match(input,IF,FOLLOW_IF_in_comp_if8160); if (state.failed) return retval; + if ( state.backtracking==0 ) { + IF317_tree = (PythonTree)adaptor.create(IF317); + adaptor.addChild(root_0, IF317_tree); + } + pushFollow(FOLLOW_test_in_comp_if8162); + test318=test(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, test318.getTree()); + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2186:38: ( comp_iter[gens, ifs] )? + int alt162=2; + int LA162_0 = input.LA(1); + + if ( (LA162_0==FOR||LA162_0==IF) ) { + alt162=1; + } + switch (alt162) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2186:38: comp_iter[gens, ifs] + { + pushFollow(FOLLOW_comp_iter_in_comp_if8165); + comp_iter319=comp_iter(gens, ifs); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, comp_iter319.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + ifs.add(actions.castExpr((test318!=null?((PythonTree)test318.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "comp_if" + + public static class yield_expr_return extends ParserRuleReturnScope { + public expr etype; + PythonTree tree; + public Object getTree() { return tree; } + }; + + // $ANTLR start "yield_expr" + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2193:1: yield_expr returns [expr etype] : YIELD ( testlist[expr_contextType.Load] )? ; + public final PythonParser.yield_expr_return yield_expr() throws RecognitionException { + PythonParser.yield_expr_return retval = new PythonParser.yield_expr_return(); + retval.start = input.LT(1); + + PythonTree root_0 = null; + + Token YIELD320=null; + PythonParser.testlist_return testlist321 = null; + + + PythonTree YIELD320_tree=null; + + try { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2199:5: ( YIELD ( testlist[expr_contextType.Load] )? ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2199:7: YIELD ( testlist[expr_contextType.Load] )? + { + root_0 = (PythonTree)adaptor.nil(); + + YIELD320=(Token)match(input,YIELD,FOLLOW_YIELD_in_yield_expr8206); if (state.failed) return retval; + if ( state.backtracking==0 ) { + YIELD320_tree = (PythonTree)adaptor.create(YIELD320); + adaptor.addChild(root_0, YIELD320_tree); + } + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2199:13: ( testlist[expr_contextType.Load] )? + int alt163=2; + int LA163_0 = input.LA(1); + + if ( (LA163_0==NAME||LA163_0==NOT||LA163_0==LPAREN||(LA163_0>=PLUS && LA163_0<=MINUS)||(LA163_0>=TILDE && LA163_0<=LBRACK)||LA163_0==LCURLY||LA163_0==BACKQUOTE) ) { + alt163=1; + } + else if ( (LA163_0==PRINT) && ((printFunction))) { + alt163=1; + } + else if ( (LA163_0==LAMBDA||(LA163_0>=INT && LA163_0<=STRING)) ) { + alt163=1; + } + switch (alt163) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:2199:13: testlist[expr_contextType.Load] + { + pushFollow(FOLLOW_testlist_in_yield_expr8208); + testlist321=testlist(expr_contextType.Load); + + state._fsp--; + if (state.failed) return retval; + if ( state.backtracking==0 ) adaptor.addChild(root_0, testlist321.getTree()); + + } + break; + + } + + if ( state.backtracking==0 ) { + + retval.etype = new Yield(YIELD320, actions.castExpr((testlist321!=null?((PythonTree)testlist321.tree):null))); + + } + + } + + retval.stop = input.LT(-1); + + if ( state.backtracking==0 ) { + + retval.tree = (PythonTree)adaptor.rulePostProcessing(root_0); + adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); + } + if ( state.backtracking==0 ) { + + //needed for y2+=yield_expr + retval.tree = retval.etype; + + } + } + + catch (RecognitionException re) { + reportError(re); + errorHandler.recover(this, input,re); + retval.tree = (PythonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); + } + finally { + } + return retval; + } + // $ANTLR end "yield_expr" + + // $ANTLR start synpred1_Python + public final void synpred1_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:579:7: ( LPAREN fpdef[null] COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:579:8: LPAREN fpdef[null] COMMA + { + match(input,LPAREN,FOLLOW_LPAREN_in_synpred1_Python1296); if (state.failed) return ; + pushFollow(FOLLOW_fpdef_in_synpred1_Python1298); + fpdef(null); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred1_Python1301); if (state.failed) return ; + + } + } + // $ANTLR end synpred1_Python + + // $ANTLR start synpred2_Python + public final void synpred2_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:8: ( testlist[null] augassign ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:643:9: testlist[null] augassign + { + pushFollow(FOLLOW_testlist_in_synpred2_Python1683); + testlist(null); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_augassign_in_synpred2_Python1686); + augassign(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred2_Python + + // $ANTLR start synpred3_Python + public final void synpred3_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:657:7: ( testlist[null] ASSIGN ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:657:8: testlist[null] ASSIGN + { + pushFollow(FOLLOW_testlist_in_synpred3_Python1802); + testlist(null); + + state._fsp--; + if (state.failed) return ; + match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred3_Python1805); if (state.failed) return ; + + } + } + // $ANTLR end synpred3_Python + + // $ANTLR start synpred4_Python + public final void synpred4_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:762:7: ( test[null] COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:762:8: test[null] COMMA + { + pushFollow(FOLLOW_test_in_synpred4_Python2317); + test(null); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred4_Python2320); if (state.failed) return ; + + } + } + // $ANTLR end synpred4_Python + + // $ANTLR start synpred5_Python + public final void synpred5_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:783:7: ( test[null] COMMA test[null] ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:783:8: test[null] COMMA test[null] + { + pushFollow(FOLLOW_test_in_synpred5_Python2416); + test(null); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred5_Python2419); if (state.failed) return ; + pushFollow(FOLLOW_test_in_synpred5_Python2421); + test(null); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred5_Python + + // $ANTLR start synpred6_Python + public final void synpred6_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1096:7: ( ( decorators )? DEF ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1096:8: ( decorators )? DEF + { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1096:8: ( decorators )? + int alt164=2; + int LA164_0 = input.LA(1); + + if ( (LA164_0==AT) ) { + alt164=1; + } + switch (alt164) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1096:8: decorators + { + pushFollow(FOLLOW_decorators_in_synpred6_Python3510); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,DEF,FOLLOW_DEF_in_synpred6_Python3513); if (state.failed) return ; + + } + } + // $ANTLR end synpred6_Python + + // $ANTLR start synpred7_Python + public final void synpred7_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1292:9: ( IF or_test[null] ORELSE ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1292:10: IF or_test[null] ORELSE + { + match(input,IF,FOLLOW_IF_in_synpred7_Python4270); if (state.failed) return ; + pushFollow(FOLLOW_or_test_in_synpred7_Python4272); + or_test(null); + + state._fsp--; + if (state.failed) return ; + match(input,ORELSE,FOLLOW_ORELSE_in_synpred7_Python4275); if (state.failed) return ; + + } + } + // $ANTLR end synpred7_Python + + // $ANTLR start synpred8_Python + public final void synpred8_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1916:7: ( test[null] COLON ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1916:8: test[null] COLON + { + pushFollow(FOLLOW_test_in_synpred8_Python6864); + test(null); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_synpred8_Python6867); if (state.failed) return ; + + } + } + // $ANTLR end synpred8_Python + + // $ANTLR start synpred9_Python + public final void synpred9_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1921:7: ( COLON ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1921:8: COLON + { + match(input,COLON,FOLLOW_COLON_in_synpred9_Python6915); if (state.failed) return ; + + } + } + // $ANTLR end synpred9_Python + + // $ANTLR start synpred10_Python + public final void synpred10_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:7: ( expr[null] COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1955:8: expr[null] COMMA + { + pushFollow(FOLLOW_expr_in_synpred10_Python7060); + expr(null); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred10_Python7063); if (state.failed) return ; + + } + } + // $ANTLR end synpred10_Python + + // $ANTLR start synpred11_Python + public final void synpred11_Python_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1985:7: ( test[null] COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/Python.g:1985:8: test[null] COMMA + { + pushFollow(FOLLOW_test_in_synpred11_Python7211); + test(null); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred11_Python7214); if (state.failed) return ; + + } + } + // $ANTLR end synpred11_Python + + // Delegated rules + + public final boolean synpred1_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred3_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred10_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred10_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred11_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred11_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred2_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred5_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred5_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred6_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred6_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred8_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred8_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred9_Python() { + state.backtracking++; + int start = input.mark(); + try { + synpred9_Python_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA30 dfa30 = new DFA30(this); + protected DFA35 dfa35 = new DFA35(this); + protected DFA31 dfa31 = new DFA31(this); + protected DFA40 dfa40 = new DFA40(this); + protected DFA38 dfa38 = new DFA38(this); + protected DFA43 dfa43 = new DFA43(this); + protected DFA41 dfa41 = new DFA41(this); + protected DFA52 dfa52 = new DFA52(this); + protected DFA80 dfa80 = new DFA80(this); + protected DFA89 dfa89 = new DFA89(this); + protected DFA112 dfa112 = new DFA112(this); + protected DFA116 dfa116 = new DFA116(this); + protected DFA129 dfa129 = new DFA129(this); + protected DFA133 dfa133 = new DFA133(this); + protected DFA131 dfa131 = new DFA131(this); + protected DFA134 dfa134 = new DFA134(this); + protected DFA138 dfa138 = new DFA138(this); + protected DFA136 dfa136 = new DFA136(this); + protected DFA139 dfa139 = new DFA139(this); + static final String DFA30_eotS = + "\13\uffff"; + static final String DFA30_eofS = + "\13\uffff"; + static final String DFA30_minS = + "\1\11\1\uffff\1\0\10\uffff"; + static final String DFA30_maxS = + "\1\132\1\uffff\1\0\10\uffff"; + static final String DFA30_acceptS = + "\1\uffff\1\1\1\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11"; + static final String DFA30_specialS = + "\1\1\1\uffff\1\0\10\uffff}>"; + static final String[] DFA30_transitionS = { + "\1\1\1\uffff\1\2\2\uffff\1\11\1\5\1\uffff\1\5\1\uffff\1\3\2"+ + "\uffff\1\10\1\uffff\1\6\1\uffff\1\7\1\uffff\1\6\2\uffff\2\1"+ + "\2\uffff\1\4\2\5\3\uffff\1\5\1\uffff\1\1\37\uffff\2\1\3\uffff"+ + "\2\1\1\uffff\1\1\1\uffff\6\1", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS); + static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS); + static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS); + static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS); + static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS); + static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS); + static final short[][] DFA30_transition; + + static { + int numStates = DFA30_transitionS.length; + DFA30_transition = new short[numStates][]; + for (int i=0; i print_stmt );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA30_2 = input.LA(1); + + + int index30_2 = input.index(); + input.rewind(); + s = -1; + if ( ((printFunction)) ) {s = 1;} + + else if ( ((!printFunction)) ) {s = 10;} + + + input.seek(index30_2); + if ( s>=0 ) return s; + break; + case 1 : + int LA30_0 = input.LA(1); + + + int index30_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA30_0==NAME||(LA30_0>=LAMBDA && LA30_0<=NOT)||LA30_0==LPAREN||(LA30_0>=PLUS && LA30_0<=MINUS)||(LA30_0>=TILDE && LA30_0<=LBRACK)||LA30_0==LCURLY||(LA30_0>=BACKQUOTE && LA30_0<=STRING)) ) {s = 1;} + + else if ( (LA30_0==PRINT) && (((printFunction)||(!printFunction)))) {s = 2;} + + else if ( (LA30_0==DELETE) ) {s = 3;} + + else if ( (LA30_0==PASS) ) {s = 4;} + + else if ( (LA30_0==BREAK||LA30_0==CONTINUE||(LA30_0>=RAISE && LA30_0<=RETURN)||LA30_0==YIELD) ) {s = 5;} + + else if ( (LA30_0==FROM||LA30_0==IMPORT) ) {s = 6;} + + else if ( (LA30_0==GLOBAL) ) {s = 7;} + + else if ( (LA30_0==EXEC) ) {s = 8;} + + else if ( (LA30_0==ASSERT) ) {s = 9;} + + + input.seek(index30_0); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 30, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA35_eotS = + "\24\uffff"; + static final String DFA35_eofS = + "\24\uffff"; + static final String DFA35_minS = + "\1\11\20\0\3\uffff"; + static final String DFA35_maxS = + "\1\132\20\0\3\uffff"; + static final String DFA35_acceptS = + "\21\uffff\1\1\1\2\1\3"; + static final String DFA35_specialS = + "\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1"+ + "\16\1\17\1\20\3\uffff}>"; + static final String[] DFA35_transitionS = { + "\1\11\1\uffff\1\12\23\uffff\1\20\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\13\1\14\1"+ + "\15\1\16\1\17", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "" + }; + + static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS); + static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS); + static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS); + static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS); + static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS); + static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS); + static final short[][] DFA35_transition; + + static { + int numStates = DFA35_transitionS.length; + DFA35_transition = new short[numStates][]; + for (int i=0; ilhs= testlist[expr_contextType.AugStore] ( (aay= augassign y1= yield_expr ) | (aat= augassign rhs= testlist[expr_contextType.Load] ) ) | ( testlist[null] ASSIGN )=>lhs= testlist[expr_contextType.Store] ( | ( (at= ASSIGN t+= testlist[expr_contextType.Store] )+ ) | ( (ay= ASSIGN y2+= yield_expr )+ ) ) | lhs= testlist[expr_contextType.Load] )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA35_0 = input.LA(1); + + + int index35_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA35_0==NOT) ) {s = 1;} + + else if ( (LA35_0==PLUS) ) {s = 2;} + + else if ( (LA35_0==MINUS) ) {s = 3;} + + else if ( (LA35_0==TILDE) ) {s = 4;} + + else if ( (LA35_0==LPAREN) ) {s = 5;} + + else if ( (LA35_0==LBRACK) ) {s = 6;} + + else if ( (LA35_0==LCURLY) ) {s = 7;} + + else if ( (LA35_0==BACKQUOTE) ) {s = 8;} + + else if ( (LA35_0==NAME) ) {s = 9;} + + else if ( (LA35_0==PRINT) && ((printFunction))) {s = 10;} + + else if ( (LA35_0==INT) ) {s = 11;} + + else if ( (LA35_0==LONGINT) ) {s = 12;} + + else if ( (LA35_0==FLOAT) ) {s = 13;} + + else if ( (LA35_0==COMPLEX) ) {s = 14;} + + else if ( (LA35_0==STRING) ) {s = 15;} + + else if ( (LA35_0==LAMBDA) ) {s = 16;} + + + input.seek(index35_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA35_1 = input.LA(1); + + + int index35_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA35_2 = input.LA(1); + + + int index35_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA35_3 = input.LA(1); + + + int index35_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA35_4 = input.LA(1); + + + int index35_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_4); + if ( s>=0 ) return s; + break; + case 5 : + int LA35_5 = input.LA(1); + + + int index35_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_5); + if ( s>=0 ) return s; + break; + case 6 : + int LA35_6 = input.LA(1); + + + int index35_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_6); + if ( s>=0 ) return s; + break; + case 7 : + int LA35_7 = input.LA(1); + + + int index35_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_7); + if ( s>=0 ) return s; + break; + case 8 : + int LA35_8 = input.LA(1); + + + int index35_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_8); + if ( s>=0 ) return s; + break; + case 9 : + int LA35_9 = input.LA(1); + + + int index35_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_9); + if ( s>=0 ) return s; + break; + case 10 : + int LA35_10 = input.LA(1); + + + int index35_10 = input.index(); + input.rewind(); + s = -1; + if ( (((synpred2_Python()&&(printFunction))||(synpred2_Python()&&(printFunction)))) ) {s = 17;} + + else if ( (((synpred3_Python()&&(printFunction))||(synpred3_Python()&&(printFunction)))) ) {s = 18;} + + else if ( ((printFunction)) ) {s = 19;} + + + input.seek(index35_10); + if ( s>=0 ) return s; + break; + case 11 : + int LA35_11 = input.LA(1); + + + int index35_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_11); + if ( s>=0 ) return s; + break; + case 12 : + int LA35_12 = input.LA(1); + + + int index35_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_12); + if ( s>=0 ) return s; + break; + case 13 : + int LA35_13 = input.LA(1); + + + int index35_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_13); + if ( s>=0 ) return s; + break; + case 14 : + int LA35_14 = input.LA(1); + + + int index35_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_14); + if ( s>=0 ) return s; + break; + case 15 : + int LA35_15 = input.LA(1); + + + int index35_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_15); + if ( s>=0 ) return s; + break; + case 16 : + int LA35_16 = input.LA(1); + + + int index35_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_Python()) ) {s = 17;} + + else if ( (synpred3_Python()) ) {s = 18;} + + else if ( (true) ) {s = 19;} + + + input.seek(index35_16); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 35, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA31_eotS = + "\17\uffff"; + static final String DFA31_eofS = + "\17\uffff"; + static final String DFA31_minS = + "\1\63\14\11\2\uffff"; + static final String DFA31_maxS = + "\1\76\14\132\2\uffff"; + static final String DFA31_acceptS = + "\15\uffff\1\2\1\1"; + static final String DFA31_specialS = + "\17\uffff}>"; + static final String[] DFA31_transitionS = { + "\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "\1\15\1\uffff\1\15\23\uffff\2\15\10\uffff\1\16\1\uffff\1\15"+ + "\37\uffff\2\15\3\uffff\2\15\1\uffff\1\15\1\uffff\6\15", + "", + "" + }; + + static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS); + static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS); + static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS); + static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS); + static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS); + static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS); + static final short[][] DFA31_transition; + + static { + int numStates = DFA31_transitionS.length; + DFA31_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA40_transitionS = { + "\1\11\1\uffff\1\12\23\uffff\1\20\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\13\1\14\1"+ + "\15\1\16\1\17", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA40_eot = DFA.unpackEncodedString(DFA40_eotS); + static final short[] DFA40_eof = DFA.unpackEncodedString(DFA40_eofS); + static final char[] DFA40_min = DFA.unpackEncodedStringToUnsignedChars(DFA40_minS); + static final char[] DFA40_max = DFA.unpackEncodedStringToUnsignedChars(DFA40_maxS); + static final short[] DFA40_accept = DFA.unpackEncodedString(DFA40_acceptS); + static final short[] DFA40_special = DFA.unpackEncodedString(DFA40_specialS); + static final short[][] DFA40_transition; + + static { + int numStates = DFA40_transitionS.length; + DFA40_transition = new short[numStates][]; + for (int i=0; it+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA40_0 = input.LA(1); + + + int index40_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA40_0==NOT) ) {s = 1;} + + else if ( (LA40_0==PLUS) ) {s = 2;} + + else if ( (LA40_0==MINUS) ) {s = 3;} + + else if ( (LA40_0==TILDE) ) {s = 4;} + + else if ( (LA40_0==LPAREN) ) {s = 5;} + + else if ( (LA40_0==LBRACK) ) {s = 6;} + + else if ( (LA40_0==LCURLY) ) {s = 7;} + + else if ( (LA40_0==BACKQUOTE) ) {s = 8;} + + else if ( (LA40_0==NAME) ) {s = 9;} + + else if ( (LA40_0==PRINT) && ((printFunction))) {s = 10;} + + else if ( (LA40_0==INT) ) {s = 11;} + + else if ( (LA40_0==LONGINT) ) {s = 12;} + + else if ( (LA40_0==FLOAT) ) {s = 13;} + + else if ( (LA40_0==COMPLEX) ) {s = 14;} + + else if ( (LA40_0==STRING) ) {s = 15;} + + else if ( (LA40_0==LAMBDA) ) {s = 16;} + + + input.seek(index40_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA40_1 = input.LA(1); + + + int index40_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA40_2 = input.LA(1); + + + int index40_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA40_3 = input.LA(1); + + + int index40_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA40_4 = input.LA(1); + + + int index40_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_4); + if ( s>=0 ) return s; + break; + case 5 : + int LA40_5 = input.LA(1); + + + int index40_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_5); + if ( s>=0 ) return s; + break; + case 6 : + int LA40_6 = input.LA(1); + + + int index40_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_6); + if ( s>=0 ) return s; + break; + case 7 : + int LA40_7 = input.LA(1); + + + int index40_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_7); + if ( s>=0 ) return s; + break; + case 8 : + int LA40_8 = input.LA(1); + + + int index40_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_8); + if ( s>=0 ) return s; + break; + case 9 : + int LA40_9 = input.LA(1); + + + int index40_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_9); + if ( s>=0 ) return s; + break; + case 10 : + int LA40_10 = input.LA(1); + + + int index40_10 = input.index(); + input.rewind(); + s = -1; + if ( ((synpred4_Python()&&(printFunction))) ) {s = 17;} + + else if ( ((printFunction)) ) {s = 18;} + + + input.seek(index40_10); + if ( s>=0 ) return s; + break; + case 11 : + int LA40_11 = input.LA(1); + + + int index40_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_11); + if ( s>=0 ) return s; + break; + case 12 : + int LA40_12 = input.LA(1); + + + int index40_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_12); + if ( s>=0 ) return s; + break; + case 13 : + int LA40_13 = input.LA(1); + + + int index40_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_13); + if ( s>=0 ) return s; + break; + case 14 : + int LA40_14 = input.LA(1); + + + int index40_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_14); + if ( s>=0 ) return s; + break; + case 15 : + int LA40_15 = input.LA(1); + + + int index40_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_15); + if ( s>=0 ) return s; + break; + case 16 : + int LA40_16 = input.LA(1); + + + int index40_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index40_16); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 40, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA38_eotS = + "\26\uffff"; + static final String DFA38_eofS = + "\26\uffff"; + static final String DFA38_minS = + "\2\7\24\uffff"; + static final String DFA38_maxS = + "\1\62\1\132\24\uffff"; + static final String DFA38_acceptS = + "\2\uffff\1\2\3\uffff\1\1\17\uffff"; + static final String DFA38_specialS = + "\26\uffff}>"; + static final String[] DFA38_transitionS = { + "\1\2\47\uffff\1\1\2\uffff\1\2", + "\1\2\1\uffff\1\6\1\uffff\1\6\23\uffff\2\6\12\uffff\1\6\6\uffff"+ + "\1\2\30\uffff\2\6\3\uffff\2\6\1\uffff\1\6\1\uffff\6\6", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS); + static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS); + static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS); + static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS); + static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS); + static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS); + static final short[][] DFA38_transition; + + static { + int numStates = DFA38_transitionS.length; + DFA38_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA43_transitionS = { + "\1\11\1\uffff\1\12\23\uffff\1\20\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\13\1\14\1"+ + "\15\1\16\1\17", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA43_eot = DFA.unpackEncodedString(DFA43_eotS); + static final short[] DFA43_eof = DFA.unpackEncodedString(DFA43_eofS); + static final char[] DFA43_min = DFA.unpackEncodedStringToUnsignedChars(DFA43_minS); + static final char[] DFA43_max = DFA.unpackEncodedStringToUnsignedChars(DFA43_maxS); + static final short[] DFA43_accept = DFA.unpackEncodedString(DFA43_acceptS); + static final short[] DFA43_special = DFA.unpackEncodedString(DFA43_specialS); + static final short[][] DFA43_transition; + + static { + int numStates = DFA43_transitionS.length; + DFA43_transition = new short[numStates][]; + for (int i=0; it+= test[expr_contextType.Load] ( options {k=2; } : COMMA t+= test[expr_contextType.Load] )* (trailcomma= COMMA )? | t+= test[expr_contextType.Load] );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA43_0 = input.LA(1); + + + int index43_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA43_0==NOT) ) {s = 1;} + + else if ( (LA43_0==PLUS) ) {s = 2;} + + else if ( (LA43_0==MINUS) ) {s = 3;} + + else if ( (LA43_0==TILDE) ) {s = 4;} + + else if ( (LA43_0==LPAREN) ) {s = 5;} + + else if ( (LA43_0==LBRACK) ) {s = 6;} + + else if ( (LA43_0==LCURLY) ) {s = 7;} + + else if ( (LA43_0==BACKQUOTE) ) {s = 8;} + + else if ( (LA43_0==NAME) ) {s = 9;} + + else if ( (LA43_0==PRINT) && ((printFunction))) {s = 10;} + + else if ( (LA43_0==INT) ) {s = 11;} + + else if ( (LA43_0==LONGINT) ) {s = 12;} + + else if ( (LA43_0==FLOAT) ) {s = 13;} + + else if ( (LA43_0==COMPLEX) ) {s = 14;} + + else if ( (LA43_0==STRING) ) {s = 15;} + + else if ( (LA43_0==LAMBDA) ) {s = 16;} + + + input.seek(index43_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA43_1 = input.LA(1); + + + int index43_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA43_2 = input.LA(1); + + + int index43_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA43_3 = input.LA(1); + + + int index43_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA43_4 = input.LA(1); + + + int index43_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_4); + if ( s>=0 ) return s; + break; + case 5 : + int LA43_5 = input.LA(1); + + + int index43_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_5); + if ( s>=0 ) return s; + break; + case 6 : + int LA43_6 = input.LA(1); + + + int index43_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_6); + if ( s>=0 ) return s; + break; + case 7 : + int LA43_7 = input.LA(1); + + + int index43_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_7); + if ( s>=0 ) return s; + break; + case 8 : + int LA43_8 = input.LA(1); + + + int index43_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_8); + if ( s>=0 ) return s; + break; + case 9 : + int LA43_9 = input.LA(1); + + + int index43_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_9); + if ( s>=0 ) return s; + break; + case 10 : + int LA43_10 = input.LA(1); + + + int index43_10 = input.index(); + input.rewind(); + s = -1; + if ( ((synpred5_Python()&&(printFunction))) ) {s = 17;} + + else if ( ((printFunction)) ) {s = 18;} + + + input.seek(index43_10); + if ( s>=0 ) return s; + break; + case 11 : + int LA43_11 = input.LA(1); + + + int index43_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_11); + if ( s>=0 ) return s; + break; + case 12 : + int LA43_12 = input.LA(1); + + + int index43_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_12); + if ( s>=0 ) return s; + break; + case 13 : + int LA43_13 = input.LA(1); + + + int index43_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_13); + if ( s>=0 ) return s; + break; + case 14 : + int LA43_14 = input.LA(1); + + + int index43_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_14); + if ( s>=0 ) return s; + break; + case 15 : + int LA43_15 = input.LA(1); + + + int index43_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_15); + if ( s>=0 ) return s; + break; + case 16 : + int LA43_16 = input.LA(1); + + + int index43_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index43_16); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 43, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA41_eotS = + "\26\uffff"; + static final String DFA41_eofS = + "\26\uffff"; + static final String DFA41_minS = + "\2\7\24\uffff"; + static final String DFA41_maxS = + "\1\62\1\132\24\uffff"; + static final String DFA41_acceptS = + "\2\uffff\1\2\3\uffff\1\1\17\uffff"; + static final String DFA41_specialS = + "\26\uffff}>"; + static final String[] DFA41_transitionS = { + "\1\2\47\uffff\1\1\2\uffff\1\2", + "\1\2\1\uffff\1\6\1\uffff\1\6\23\uffff\2\6\12\uffff\1\6\6\uffff"+ + "\1\2\30\uffff\2\6\3\uffff\2\6\1\uffff\1\6\1\uffff\6\6", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA41_eot = DFA.unpackEncodedString(DFA41_eotS); + static final short[] DFA41_eof = DFA.unpackEncodedString(DFA41_eofS); + static final char[] DFA41_min = DFA.unpackEncodedStringToUnsignedChars(DFA41_minS); + static final char[] DFA41_max = DFA.unpackEncodedStringToUnsignedChars(DFA41_maxS); + static final short[] DFA41_accept = DFA.unpackEncodedString(DFA41_acceptS); + static final short[] DFA41_special = DFA.unpackEncodedString(DFA41_specialS); + static final short[][] DFA41_transition; + + static { + int numStates = DFA41_transitionS.length; + DFA41_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA52_transitionS = { + "\1\2\1\1", + "\1\2\1\1\21\uffff\1\3", + "", + "" + }; + + static final short[] DFA52_eot = DFA.unpackEncodedString(DFA52_eotS); + static final short[] DFA52_eof = DFA.unpackEncodedString(DFA52_eofS); + static final char[] DFA52_min = DFA.unpackEncodedStringToUnsignedChars(DFA52_minS); + static final char[] DFA52_max = DFA.unpackEncodedStringToUnsignedChars(DFA52_maxS); + static final short[] DFA52_accept = DFA.unpackEncodedString(DFA52_acceptS); + static final short[] DFA52_special = DFA.unpackEncodedString(DFA52_specialS); + static final short[][] DFA52_transition; + + static { + int numStates = DFA52_transitionS.length; + DFA52_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA80_transitionS = { + "\1\2\5\uffff\1\2\13\uffff\1\2\1\uffff\1\1\20\uffff\4\2\2\uffff"+ + "\15\2\23\uffff\1\2\1\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA80_eot = DFA.unpackEncodedString(DFA80_eotS); + static final short[] DFA80_eof = DFA.unpackEncodedString(DFA80_eofS); + static final char[] DFA80_min = DFA.unpackEncodedStringToUnsignedChars(DFA80_minS); + static final char[] DFA80_max = DFA.unpackEncodedStringToUnsignedChars(DFA80_maxS); + static final short[] DFA80_accept = DFA.unpackEncodedString(DFA80_acceptS); + static final short[] DFA80_special = DFA.unpackEncodedString(DFA80_specialS); + static final short[][] DFA80_transition; + + static { + int numStates = DFA80_transitionS.length; + DFA80_transition = new short[numStates][]; + for (int i=0; i IF o2= or_test[ctype] ORELSE e= test[expr_contextType.Load] | -> or_test )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA80_1 = input.LA(1); + + + int index80_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred7_Python()) ) {s = 26;} + + else if ( (true) ) {s = 2;} + + + input.seek(index80_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 80, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA89_eotS = + "\15\uffff"; + static final String DFA89_eofS = + "\15\uffff"; + static final String DFA89_minS = + "\1\35\11\uffff\1\11\2\uffff"; + static final String DFA89_maxS = + "\1\106\11\uffff\1\132\2\uffff"; + static final String DFA89_acceptS = + "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\uffff\1\13\1\12"; + static final String DFA89_specialS = + "\15\uffff}>"; + static final String[] DFA89_transitionS = { + "\1\10\1\12\1\uffff\1\11\37\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\14\1\uffff\1\14\24\uffff\1\13\12\uffff\1\14\37\uffff\2\14"+ + "\3\uffff\2\14\1\uffff\1\14\1\uffff\6\14", + "", + "" + }; + + static final short[] DFA89_eot = DFA.unpackEncodedString(DFA89_eotS); + static final short[] DFA89_eof = DFA.unpackEncodedString(DFA89_eofS); + static final char[] DFA89_min = DFA.unpackEncodedStringToUnsignedChars(DFA89_minS); + static final char[] DFA89_max = DFA.unpackEncodedStringToUnsignedChars(DFA89_maxS); + static final short[] DFA89_accept = DFA.unpackEncodedString(DFA89_acceptS); + static final short[] DFA89_special = DFA.unpackEncodedString(DFA89_specialS); + static final short[][] DFA89_transition; + + static { + int numStates = DFA89_transitionS.length; + DFA89_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA112_transitionS = { + "\1\5\1\uffff\1\6\37\uffff\1\1\45\uffff\1\2\1\uffff\1\3\1\uffff"+ + "\1\4\1\7\1\10\1\11\1\12\1\13", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS); + static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS); + static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS); + static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS); + static final short[] DFA112_accept = DFA.unpackEncodedString(DFA112_acceptS); + static final short[] DFA112_special = DFA.unpackEncodedString(DFA112_specialS); + static final short[][] DFA112_transition; + + static { + int numStates = DFA112_transitionS.length; + DFA112_transition = new short[numStates][]; + for (int i=0; i testlist_gexp | ) RPAREN | LBRACK ( listmaker[$LBRACK] -> listmaker | ) RBRACK | LCURLY ( dictorsetmaker[$LCURLY] -> dictorsetmaker | ) RCURLY | lb= BACKQUOTE testlist[expr_contextType.Load] rb= BACKQUOTE | name_or_print | INT | LONGINT | FLOAT | COMPLEX | (S+= STRING )+ );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA112_0 = input.LA(1); + + + int index112_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA112_0==LPAREN) ) {s = 1;} + + else if ( (LA112_0==LBRACK) ) {s = 2;} + + else if ( (LA112_0==LCURLY) ) {s = 3;} + + else if ( (LA112_0==BACKQUOTE) ) {s = 4;} + + else if ( (LA112_0==NAME) ) {s = 5;} + + else if ( (LA112_0==PRINT) && ((printFunction))) {s = 6;} + + else if ( (LA112_0==INT) ) {s = 7;} + + else if ( (LA112_0==LONGINT) ) {s = 8;} + + else if ( (LA112_0==FLOAT) ) {s = 9;} + + else if ( (LA112_0==COMPLEX) ) {s = 10;} + + else if ( (LA112_0==STRING) ) {s = 11;} + + + input.seek(index112_0); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 112, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA116_eotS = + "\24\uffff"; + static final String DFA116_eofS = + "\24\uffff"; + static final String DFA116_minS = + "\1\54\1\11\22\uffff"; + static final String DFA116_maxS = + "\1\57\1\132\22\uffff"; + static final String DFA116_acceptS = + "\2\uffff\1\2\1\uffff\1\1\17\uffff"; + static final String DFA116_specialS = + "\24\uffff}>"; + static final String[] DFA116_transitionS = { + "\1\2\2\uffff\1\1", + "\1\4\1\uffff\1\4\23\uffff\2\4\12\uffff\1\4\1\2\36\uffff\2\4"+ + "\3\uffff\2\4\1\uffff\1\4\1\uffff\6\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA116_eot = DFA.unpackEncodedString(DFA116_eotS); + static final short[] DFA116_eof = DFA.unpackEncodedString(DFA116_eofS); + static final char[] DFA116_min = DFA.unpackEncodedStringToUnsignedChars(DFA116_minS); + static final char[] DFA116_max = DFA.unpackEncodedStringToUnsignedChars(DFA116_maxS); + static final short[] DFA116_accept = DFA.unpackEncodedString(DFA116_acceptS); + static final short[] DFA116_special = DFA.unpackEncodedString(DFA116_specialS); + static final short[][] DFA116_transition; + + static { + int numStates = DFA116_transitionS.length; + DFA116_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA129_transitionS = { + "\1\12\1\1\1\13\23\uffff\1\21\1\2\12\uffff\1\6\1\uffff\1\22\35"+ + "\uffff\1\3\1\4\3\uffff\1\5\1\7\1\uffff\1\10\1\uffff\1\11\1\14"+ + "\1\15\1\16\1\17\1\20", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "" + }; + + static final short[] DFA129_eot = DFA.unpackEncodedString(DFA129_eotS); + static final short[] DFA129_eof = DFA.unpackEncodedString(DFA129_eofS); + static final char[] DFA129_min = DFA.unpackEncodedStringToUnsignedChars(DFA129_minS); + static final char[] DFA129_max = DFA.unpackEncodedStringToUnsignedChars(DFA129_maxS); + static final short[] DFA129_accept = DFA.unpackEncodedString(DFA129_acceptS); + static final short[] DFA129_special = DFA.unpackEncodedString(DFA129_specialS); + static final short[][] DFA129_transition; + + static { + int numStates = DFA129_transitionS.length; + DFA129_transition = new short[numStates][]; + for (int i=0; ilower= test[expr_contextType.Load] (c1= COLON (upper1= test[expr_contextType.Load] )? ( sliceop )? )? | ( COLON )=>c2= COLON (upper2= test[expr_contextType.Load] )? ( sliceop )? | test[expr_contextType.Load] );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA129_0 = input.LA(1); + + + int index129_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA129_0==DOT) ) {s = 1;} + + else if ( (LA129_0==NOT) ) {s = 2;} + + else if ( (LA129_0==PLUS) ) {s = 3;} + + else if ( (LA129_0==MINUS) ) {s = 4;} + + else if ( (LA129_0==TILDE) ) {s = 5;} + + else if ( (LA129_0==LPAREN) ) {s = 6;} + + else if ( (LA129_0==LBRACK) ) {s = 7;} + + else if ( (LA129_0==LCURLY) ) {s = 8;} + + else if ( (LA129_0==BACKQUOTE) ) {s = 9;} + + else if ( (LA129_0==NAME) ) {s = 10;} + + else if ( (LA129_0==PRINT) && ((printFunction))) {s = 11;} + + else if ( (LA129_0==INT) ) {s = 12;} + + else if ( (LA129_0==LONGINT) ) {s = 13;} + + else if ( (LA129_0==FLOAT) ) {s = 14;} + + else if ( (LA129_0==COMPLEX) ) {s = 15;} + + else if ( (LA129_0==STRING) ) {s = 16;} + + else if ( (LA129_0==LAMBDA) ) {s = 17;} + + else if ( (LA129_0==COLON) && (synpred9_Python())) {s = 18;} + + + input.seek(index129_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA129_2 = input.LA(1); + + + int index129_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA129_3 = input.LA(1); + + + int index129_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA129_4 = input.LA(1); + + + int index129_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA129_5 = input.LA(1); + + + int index129_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA129_6 = input.LA(1); + + + int index129_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA129_7 = input.LA(1); + + + int index129_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA129_8 = input.LA(1); + + + int index129_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA129_9 = input.LA(1); + + + int index129_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA129_10 = input.LA(1); + + + int index129_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA129_11 = input.LA(1); + + + int index129_11 = input.index(); + input.rewind(); + s = -1; + if ( ((synpred8_Python()&&(printFunction))) ) {s = 19;} + + else if ( ((printFunction)) ) {s = 20;} + + + input.seek(index129_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA129_12 = input.LA(1); + + + int index129_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA129_13 = input.LA(1); + + + int index129_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA129_14 = input.LA(1); + + + int index129_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA129_15 = input.LA(1); + + + int index129_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA129_16 = input.LA(1); + + + int index129_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA129_17 = input.LA(1); + + + int index129_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_Python()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index129_17); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 129, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA133_eotS = + "\21\uffff"; + static final String DFA133_eofS = + "\21\uffff"; + static final String DFA133_minS = + "\1\11\16\0\2\uffff"; + static final String DFA133_maxS = + "\1\132\16\0\2\uffff"; + static final String DFA133_acceptS = + "\17\uffff\1\1\1\2"; + static final String DFA133_specialS = + "\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1"+ + "\16\2\uffff}>"; + static final String[] DFA133_transitionS = { + "\1\10\1\uffff\1\11\37\uffff\1\4\37\uffff\1\1\1\2\3\uffff\1\3"+ + "\1\5\1\uffff\1\6\1\uffff\1\7\1\12\1\13\1\14\1\15\1\16", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA133_eot = DFA.unpackEncodedString(DFA133_eotS); + static final short[] DFA133_eof = DFA.unpackEncodedString(DFA133_eofS); + static final char[] DFA133_min = DFA.unpackEncodedStringToUnsignedChars(DFA133_minS); + static final char[] DFA133_max = DFA.unpackEncodedStringToUnsignedChars(DFA133_maxS); + static final short[] DFA133_accept = DFA.unpackEncodedString(DFA133_acceptS); + static final short[] DFA133_special = DFA.unpackEncodedString(DFA133_specialS); + static final short[][] DFA133_transition; + + static { + int numStates = DFA133_transitionS.length; + DFA133_transition = new short[numStates][]; + for (int i=0; ie+= expr[ctype] ( options {k=2; } : COMMA e+= expr[ctype] )* ( COMMA )? | expr[ctype] );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA133_0 = input.LA(1); + + + int index133_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA133_0==PLUS) ) {s = 1;} + + else if ( (LA133_0==MINUS) ) {s = 2;} + + else if ( (LA133_0==TILDE) ) {s = 3;} + + else if ( (LA133_0==LPAREN) ) {s = 4;} + + else if ( (LA133_0==LBRACK) ) {s = 5;} + + else if ( (LA133_0==LCURLY) ) {s = 6;} + + else if ( (LA133_0==BACKQUOTE) ) {s = 7;} + + else if ( (LA133_0==NAME) ) {s = 8;} + + else if ( (LA133_0==PRINT) && ((printFunction))) {s = 9;} + + else if ( (LA133_0==INT) ) {s = 10;} + + else if ( (LA133_0==LONGINT) ) {s = 11;} + + else if ( (LA133_0==FLOAT) ) {s = 12;} + + else if ( (LA133_0==COMPLEX) ) {s = 13;} + + else if ( (LA133_0==STRING) ) {s = 14;} + + + input.seek(index133_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA133_1 = input.LA(1); + + + int index133_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA133_2 = input.LA(1); + + + int index133_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA133_3 = input.LA(1); + + + int index133_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA133_4 = input.LA(1); + + + int index133_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_4); + if ( s>=0 ) return s; + break; + case 5 : + int LA133_5 = input.LA(1); + + + int index133_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_5); + if ( s>=0 ) return s; + break; + case 6 : + int LA133_6 = input.LA(1); + + + int index133_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_6); + if ( s>=0 ) return s; + break; + case 7 : + int LA133_7 = input.LA(1); + + + int index133_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_7); + if ( s>=0 ) return s; + break; + case 8 : + int LA133_8 = input.LA(1); + + + int index133_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_8); + if ( s>=0 ) return s; + break; + case 9 : + int LA133_9 = input.LA(1); + + + int index133_9 = input.index(); + input.rewind(); + s = -1; + if ( ((synpred10_Python()&&(printFunction))) ) {s = 15;} + + else if ( ((printFunction)) ) {s = 16;} + + + input.seek(index133_9); + if ( s>=0 ) return s; + break; + case 10 : + int LA133_10 = input.LA(1); + + + int index133_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_10); + if ( s>=0 ) return s; + break; + case 11 : + int LA133_11 = input.LA(1); + + + int index133_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_11); + if ( s>=0 ) return s; + break; + case 12 : + int LA133_12 = input.LA(1); + + + int index133_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_12); + if ( s>=0 ) return s; + break; + case 13 : + int LA133_13 = input.LA(1); + + + int index133_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_13); + if ( s>=0 ) return s; + break; + case 14 : + int LA133_14 = input.LA(1); + + + int index133_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_Python()) ) {s = 15;} + + else if ( (true) ) {s = 16;} + + + input.seek(index133_14); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 133, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA131_eotS = + "\22\uffff"; + static final String DFA131_eofS = + "\22\uffff"; + static final String DFA131_minS = + "\1\35\1\11\20\uffff"; + static final String DFA131_maxS = + "\1\57\1\132\20\uffff"; + static final String DFA131_acceptS = + "\2\uffff\1\2\1\uffff\1\1\15\uffff"; + static final String DFA131_specialS = + "\22\uffff}>"; + static final String[] DFA131_transitionS = { + "\1\2\21\uffff\1\1", + "\1\4\1\uffff\1\4\21\uffff\1\2\15\uffff\1\4\37\uffff\2\4\3\uffff"+ + "\2\4\1\uffff\1\4\1\uffff\6\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA131_eot = DFA.unpackEncodedString(DFA131_eotS); + static final short[] DFA131_eof = DFA.unpackEncodedString(DFA131_eofS); + static final char[] DFA131_min = DFA.unpackEncodedStringToUnsignedChars(DFA131_minS); + static final char[] DFA131_max = DFA.unpackEncodedStringToUnsignedChars(DFA131_maxS); + static final short[] DFA131_accept = DFA.unpackEncodedString(DFA131_acceptS); + static final short[] DFA131_special = DFA.unpackEncodedString(DFA131_specialS); + static final short[][] DFA131_transition; + + static { + int numStates = DFA131_transitionS.length; + DFA131_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA134_transitionS = { + "\1\2\47\uffff\1\1\2\uffff\1\2", + "\1\2\1\uffff\1\6\1\uffff\1\6\37\uffff\1\6\6\uffff\1\2\30\uffff"+ + "\2\6\3\uffff\2\6\1\uffff\1\6\1\uffff\6\6", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA134_eot = DFA.unpackEncodedString(DFA134_eotS); + static final short[] DFA134_eof = DFA.unpackEncodedString(DFA134_eofS); + static final char[] DFA134_min = DFA.unpackEncodedStringToUnsignedChars(DFA134_minS); + static final char[] DFA134_max = DFA.unpackEncodedStringToUnsignedChars(DFA134_maxS); + static final short[] DFA134_accept = DFA.unpackEncodedString(DFA134_acceptS); + static final short[] DFA134_special = DFA.unpackEncodedString(DFA134_specialS); + static final short[][] DFA134_transition; + + static { + int numStates = DFA134_transitionS.length; + DFA134_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA138_transitionS = { + "\1\11\1\uffff\1\12\23\uffff\1\20\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\13\1\14\1"+ + "\15\1\16\1\17", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA138_eot = DFA.unpackEncodedString(DFA138_eotS); + static final short[] DFA138_eof = DFA.unpackEncodedString(DFA138_eofS); + static final char[] DFA138_min = DFA.unpackEncodedStringToUnsignedChars(DFA138_minS); + static final char[] DFA138_max = DFA.unpackEncodedStringToUnsignedChars(DFA138_maxS); + static final short[] DFA138_accept = DFA.unpackEncodedString(DFA138_acceptS); + static final short[] DFA138_special = DFA.unpackEncodedString(DFA138_specialS); + static final short[][] DFA138_transition; + + static { + int numStates = DFA138_transitionS.length; + DFA138_transition = new short[numStates][]; + for (int i=0; it+= test[ctype] ( options {k=2; } : COMMA t+= test[ctype] )* ( COMMA )? | test[ctype] );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA138_0 = input.LA(1); + + + int index138_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA138_0==NOT) ) {s = 1;} + + else if ( (LA138_0==PLUS) ) {s = 2;} + + else if ( (LA138_0==MINUS) ) {s = 3;} + + else if ( (LA138_0==TILDE) ) {s = 4;} + + else if ( (LA138_0==LPAREN) ) {s = 5;} + + else if ( (LA138_0==LBRACK) ) {s = 6;} + + else if ( (LA138_0==LCURLY) ) {s = 7;} + + else if ( (LA138_0==BACKQUOTE) ) {s = 8;} + + else if ( (LA138_0==NAME) ) {s = 9;} + + else if ( (LA138_0==PRINT) && ((printFunction))) {s = 10;} + + else if ( (LA138_0==INT) ) {s = 11;} + + else if ( (LA138_0==LONGINT) ) {s = 12;} + + else if ( (LA138_0==FLOAT) ) {s = 13;} + + else if ( (LA138_0==COMPLEX) ) {s = 14;} + + else if ( (LA138_0==STRING) ) {s = 15;} + + else if ( (LA138_0==LAMBDA) ) {s = 16;} + + + input.seek(index138_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA138_1 = input.LA(1); + + + int index138_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA138_2 = input.LA(1); + + + int index138_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA138_3 = input.LA(1); + + + int index138_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA138_4 = input.LA(1); + + + int index138_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_4); + if ( s>=0 ) return s; + break; + case 5 : + int LA138_5 = input.LA(1); + + + int index138_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_5); + if ( s>=0 ) return s; + break; + case 6 : + int LA138_6 = input.LA(1); + + + int index138_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_6); + if ( s>=0 ) return s; + break; + case 7 : + int LA138_7 = input.LA(1); + + + int index138_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_7); + if ( s>=0 ) return s; + break; + case 8 : + int LA138_8 = input.LA(1); + + + int index138_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_8); + if ( s>=0 ) return s; + break; + case 9 : + int LA138_9 = input.LA(1); + + + int index138_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_9); + if ( s>=0 ) return s; + break; + case 10 : + int LA138_10 = input.LA(1); + + + int index138_10 = input.index(); + input.rewind(); + s = -1; + if ( ((synpred11_Python()&&(printFunction))) ) {s = 17;} + + else if ( ((printFunction)) ) {s = 18;} + + + input.seek(index138_10); + if ( s>=0 ) return s; + break; + case 11 : + int LA138_11 = input.LA(1); + + + int index138_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_11); + if ( s>=0 ) return s; + break; + case 12 : + int LA138_12 = input.LA(1); + + + int index138_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_12); + if ( s>=0 ) return s; + break; + case 13 : + int LA138_13 = input.LA(1); + + + int index138_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_13); + if ( s>=0 ) return s; + break; + case 14 : + int LA138_14 = input.LA(1); + + + int index138_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_14); + if ( s>=0 ) return s; + break; + case 15 : + int LA138_15 = input.LA(1); + + + int index138_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_15); + if ( s>=0 ) return s; + break; + case 16 : + int LA138_16 = input.LA(1); + + + int index138_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_Python()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index138_16); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 138, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA136_eotS = + "\76\uffff"; + static final String DFA136_eofS = + "\2\2\74\uffff"; + static final String DFA136_minS = + "\2\7\74\uffff"; + static final String DFA136_maxS = + "\1\125\1\132\74\uffff"; + static final String DFA136_acceptS = + "\2\uffff\1\2\46\uffff\1\1\5\uffff\1\1\16\uffff"; + static final String DFA136_specialS = + "\76\uffff}>"; + static final String[] DFA136_transitionS = { + "\1\2\21\uffff\1\2\1\uffff\1\2\20\uffff\3\2\1\1\2\uffff\15\2"+ + "\23\uffff\1\2\2\uffff\1\2", + "\1\2\1\uffff\1\57\1\uffff\1\57\15\uffff\1\2\1\uffff\1\2\3\uffff"+ + "\2\57\12\uffff\1\57\4\2\2\uffff\15\2\14\uffff\2\57\3\uffff\2"+ + "\57\1\2\1\57\1\uffff\1\51\5\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA136_eot = DFA.unpackEncodedString(DFA136_eotS); + static final short[] DFA136_eof = DFA.unpackEncodedString(DFA136_eofS); + static final char[] DFA136_min = DFA.unpackEncodedStringToUnsignedChars(DFA136_minS); + static final char[] DFA136_max = DFA.unpackEncodedStringToUnsignedChars(DFA136_maxS); + static final short[] DFA136_accept = DFA.unpackEncodedString(DFA136_acceptS); + static final short[] DFA136_special = DFA.unpackEncodedString(DFA136_specialS); + static final short[][] DFA136_transition; + + static { + int numStates = DFA136_transitionS.length; + DFA136_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA139_transitionS = { + "\1\1\44\uffff\1\2", + "\1\4\1\uffff\1\4\23\uffff\2\4\12\uffff\1\4\37\uffff\2\4\3\uffff"+ + "\2\4\1\uffff\1\4\1\2\6\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA139_eot = DFA.unpackEncodedString(DFA139_eotS); + static final short[] DFA139_eof = DFA.unpackEncodedString(DFA139_eofS); + static final char[] DFA139_min = DFA.unpackEncodedStringToUnsignedChars(DFA139_minS); + static final char[] DFA139_max = DFA.unpackEncodedStringToUnsignedChars(DFA139_maxS); + static final short[] DFA139_accept = DFA.unpackEncodedString(DFA139_acceptS); + static final short[] DFA139_special = DFA.unpackEncodedString(DFA139_specialS); + static final short[][] DFA139_transition; + + static { + int numStates = DFA139_transitionS.length; + DFA139_transition = new short[numStates][]; + for (int i=0; i 0) { + eofWhileNested = true; + } + return Token.EOF_TOKEN; + } + try { + mTokens(); + if ( state.token==null ) { + emit(); + } + else if ( state.token==Token.SKIP_TOKEN ) { + continue; + } + return state.token; + } catch (NoViableAltException nva) { + errorHandler.reportError(this, nva); + errorHandler.recover(this, nva); // throw out current char and try again + } catch (FailedPredicateException fp) { + //XXX: added this for failed STRINGPART -- the FailedPredicateException + // hides a NoViableAltException. This should be the only + // FailedPredicateException that gets thrown by the lexer. + errorHandler.reportError(this, fp); + errorHandler.recover(this, fp); // throw out current char and try again + } catch (RecognitionException re) { + errorHandler.reportError(this, re); + // match() routine has already called recover() + } + } + } + + + // delegates + // delegators + + public PythonPartialLexer() {;} + public PythonPartialLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public PythonPartialLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "/Users/orion.moore/apps/code/jython/grammar/PythonPartial.g"; } + + // $ANTLR start "AS" + public final void mAS() throws RecognitionException { + try { + int _type = AS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:900:11: ( 'as' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:900:13: 'as' + { + match("as"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AS" + + // $ANTLR start "ASSERT" + public final void mASSERT() throws RecognitionException { + try { + int _type = ASSERT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:901:11: ( 'assert' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:901:13: 'assert' + { + match("assert"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ASSERT" + + // $ANTLR start "BREAK" + public final void mBREAK() throws RecognitionException { + try { + int _type = BREAK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:902:11: ( 'break' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:902:13: 'break' + { + match("break"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "BREAK" + + // $ANTLR start "CLASS" + public final void mCLASS() throws RecognitionException { + try { + int _type = CLASS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:903:11: ( 'class' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:903:13: 'class' + { + match("class"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CLASS" + + // $ANTLR start "CONTINUE" + public final void mCONTINUE() throws RecognitionException { + try { + int _type = CONTINUE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:904:11: ( 'continue' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:904:13: 'continue' + { + match("continue"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CONTINUE" + + // $ANTLR start "DEF" + public final void mDEF() throws RecognitionException { + try { + int _type = DEF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:905:11: ( 'def' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:905:13: 'def' + { + match("def"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DEF" + + // $ANTLR start "DELETE" + public final void mDELETE() throws RecognitionException { + try { + int _type = DELETE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:906:11: ( 'del' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:906:13: 'del' + { + match("del"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DELETE" + + // $ANTLR start "ELIF" + public final void mELIF() throws RecognitionException { + try { + int _type = ELIF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:907:11: ( 'elif' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:907:13: 'elif' + { + match("elif"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ELIF" + + // $ANTLR start "EXCEPT" + public final void mEXCEPT() throws RecognitionException { + try { + int _type = EXCEPT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:908:11: ( 'except' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:908:13: 'except' + { + match("except"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EXCEPT" + + // $ANTLR start "EXEC" + public final void mEXEC() throws RecognitionException { + try { + int _type = EXEC; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:909:11: ( 'exec' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:909:13: 'exec' + { + match("exec"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EXEC" + + // $ANTLR start "FINALLY" + public final void mFINALLY() throws RecognitionException { + try { + int _type = FINALLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:910:11: ( 'finally' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:910:13: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FINALLY" + + // $ANTLR start "FROM" + public final void mFROM() throws RecognitionException { + try { + int _type = FROM; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:911:11: ( 'from' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:911:13: 'from' + { + match("from"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FROM" + + // $ANTLR start "FOR" + public final void mFOR() throws RecognitionException { + try { + int _type = FOR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:912:11: ( 'for' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:912:13: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FOR" + + // $ANTLR start "GLOBAL" + public final void mGLOBAL() throws RecognitionException { + try { + int _type = GLOBAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:913:11: ( 'global' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:913:13: 'global' + { + match("global"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GLOBAL" + + // $ANTLR start "IF" + public final void mIF() throws RecognitionException { + try { + int _type = IF; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:914:11: ( 'if' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:914:13: 'if' + { + match("if"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IF" + + // $ANTLR start "IMPORT" + public final void mIMPORT() throws RecognitionException { + try { + int _type = IMPORT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:915:11: ( 'import' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:915:13: 'import' + { + match("import"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IMPORT" + + // $ANTLR start "IN" + public final void mIN() throws RecognitionException { + try { + int _type = IN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:916:11: ( 'in' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:916:13: 'in' + { + match("in"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IN" + + // $ANTLR start "IS" + public final void mIS() throws RecognitionException { + try { + int _type = IS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:917:11: ( 'is' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:917:13: 'is' + { + match("is"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "IS" + + // $ANTLR start "LAMBDA" + public final void mLAMBDA() throws RecognitionException { + try { + int _type = LAMBDA; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:918:11: ( 'lambda' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:918:13: 'lambda' + { + match("lambda"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LAMBDA" + + // $ANTLR start "ORELSE" + public final void mORELSE() throws RecognitionException { + try { + int _type = ORELSE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:919:11: ( 'else' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:919:13: 'else' + { + match("else"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ORELSE" + + // $ANTLR start "PASS" + public final void mPASS() throws RecognitionException { + try { + int _type = PASS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:920:11: ( 'pass' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:920:13: 'pass' + { + match("pass"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PASS" + + // $ANTLR start "PRINT" + public final void mPRINT() throws RecognitionException { + try { + int _type = PRINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:921:11: ( 'print' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:921:13: 'print' + { + match("print"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PRINT" + + // $ANTLR start "RAISE" + public final void mRAISE() throws RecognitionException { + try { + int _type = RAISE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:922:11: ( 'raise' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:922:13: 'raise' + { + match("raise"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RAISE" + + // $ANTLR start "RETURN" + public final void mRETURN() throws RecognitionException { + try { + int _type = RETURN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:923:11: ( 'return' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:923:13: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RETURN" + + // $ANTLR start "TRY" + public final void mTRY() throws RecognitionException { + try { + int _type = TRY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:924:11: ( 'try' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:924:13: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "TRY" + + // $ANTLR start "WHILE" + public final void mWHILE() throws RecognitionException { + try { + int _type = WHILE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:925:11: ( 'while' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:925:13: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WHILE" + + // $ANTLR start "WITH" + public final void mWITH() throws RecognitionException { + try { + int _type = WITH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:926:11: ( 'with' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:926:13: 'with' + { + match("with"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WITH" + + // $ANTLR start "YIELD" + public final void mYIELD() throws RecognitionException { + try { + int _type = YIELD; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:927:11: ( 'yield' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:927:13: 'yield' + { + match("yield"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "YIELD" + + // $ANTLR start "LPAREN" + public final void mLPAREN() throws RecognitionException { + try { + int _type = LPAREN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:929:11: ( '(' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:929:13: '(' + { + match('('); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LPAREN" + + // $ANTLR start "RPAREN" + public final void mRPAREN() throws RecognitionException { + try { + int _type = RPAREN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:931:11: ( ')' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:931:13: ')' + { + match(')'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RPAREN" + + // $ANTLR start "LBRACK" + public final void mLBRACK() throws RecognitionException { + try { + int _type = LBRACK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:933:11: ( '[' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:933:13: '[' + { + match('['); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LBRACK" + + // $ANTLR start "RBRACK" + public final void mRBRACK() throws RecognitionException { + try { + int _type = RBRACK; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:935:11: ( ']' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:935:13: ']' + { + match(']'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RBRACK" + + // $ANTLR start "COLON" + public final void mCOLON() throws RecognitionException { + try { + int _type = COLON; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:937:11: ( ':' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:937:13: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COLON" + + // $ANTLR start "COMMA" + public final void mCOMMA() throws RecognitionException { + try { + int _type = COMMA; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:939:10: ( ',' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:939:12: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMMA" + + // $ANTLR start "SEMI" + public final void mSEMI() throws RecognitionException { + try { + int _type = SEMI; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:941:9: ( ';' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:941:11: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SEMI" + + // $ANTLR start "PLUS" + public final void mPLUS() throws RecognitionException { + try { + int _type = PLUS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:943:9: ( '+' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:943:11: '+' + { + match('+'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PLUS" + + // $ANTLR start "MINUS" + public final void mMINUS() throws RecognitionException { + try { + int _type = MINUS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:945:10: ( '-' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:945:12: '-' + { + match('-'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "MINUS" + + // $ANTLR start "STAR" + public final void mSTAR() throws RecognitionException { + try { + int _type = STAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:947:9: ( '*' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:947:11: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STAR" + + // $ANTLR start "SLASH" + public final void mSLASH() throws RecognitionException { + try { + int _type = SLASH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:949:10: ( '/' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:949:12: '/' + { + match('/'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SLASH" + + // $ANTLR start "VBAR" + public final void mVBAR() throws RecognitionException { + try { + int _type = VBAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:951:9: ( '|' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:951:11: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "VBAR" + + // $ANTLR start "AMPER" + public final void mAMPER() throws RecognitionException { + try { + int _type = AMPER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:953:10: ( '&' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:953:12: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AMPER" + + // $ANTLR start "LESS" + public final void mLESS() throws RecognitionException { + try { + int _type = LESS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:955:9: ( '<' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:955:11: '<' + { + match('<'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LESS" + + // $ANTLR start "GREATER" + public final void mGREATER() throws RecognitionException { + try { + int _type = GREATER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:957:12: ( '>' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:957:14: '>' + { + match('>'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GREATER" + + // $ANTLR start "ASSIGN" + public final void mASSIGN() throws RecognitionException { + try { + int _type = ASSIGN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:959:11: ( '=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:959:13: '=' + { + match('='); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ASSIGN" + + // $ANTLR start "PERCENT" + public final void mPERCENT() throws RecognitionException { + try { + int _type = PERCENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:961:12: ( '%' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:961:14: '%' + { + match('%'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PERCENT" + + // $ANTLR start "BACKQUOTE" + public final void mBACKQUOTE() throws RecognitionException { + try { + int _type = BACKQUOTE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:963:14: ( '`' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:963:16: '`' + { + match('`'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "BACKQUOTE" + + // $ANTLR start "LCURLY" + public final void mLCURLY() throws RecognitionException { + try { + int _type = LCURLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:965:11: ( '{' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:965:13: '{' + { + match('{'); + implicitLineJoiningLevel++; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LCURLY" + + // $ANTLR start "RCURLY" + public final void mRCURLY() throws RecognitionException { + try { + int _type = RCURLY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:967:11: ( '}' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:967:13: '}' + { + match('}'); + implicitLineJoiningLevel--; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RCURLY" + + // $ANTLR start "CIRCUMFLEX" + public final void mCIRCUMFLEX() throws RecognitionException { + try { + int _type = CIRCUMFLEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:969:15: ( '^' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:969:17: '^' + { + match('^'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CIRCUMFLEX" + + // $ANTLR start "TILDE" + public final void mTILDE() throws RecognitionException { + try { + int _type = TILDE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:971:10: ( '~' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:971:12: '~' + { + match('~'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "TILDE" + + // $ANTLR start "EQUAL" + public final void mEQUAL() throws RecognitionException { + try { + int _type = EQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:973:10: ( '==' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:973:12: '==' + { + match("=="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "EQUAL" + + // $ANTLR start "NOTEQUAL" + public final void mNOTEQUAL() throws RecognitionException { + try { + int _type = NOTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:975:13: ( '!=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:975:15: '!=' + { + match("!="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NOTEQUAL" + + // $ANTLR start "ALT_NOTEQUAL" + public final void mALT_NOTEQUAL() throws RecognitionException { + try { + int _type = ALT_NOTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:977:13: ( '<>' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:977:15: '<>' + { + match("<>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ALT_NOTEQUAL" + + // $ANTLR start "LESSEQUAL" + public final void mLESSEQUAL() throws RecognitionException { + try { + int _type = LESSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:979:14: ( '<=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:979:16: '<=' + { + match("<="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LESSEQUAL" + + // $ANTLR start "LEFTSHIFT" + public final void mLEFTSHIFT() throws RecognitionException { + try { + int _type = LEFTSHIFT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:981:14: ( '<<' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:981:16: '<<' + { + match("<<"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LEFTSHIFT" + + // $ANTLR start "GREATEREQUAL" + public final void mGREATEREQUAL() throws RecognitionException { + try { + int _type = GREATEREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:983:17: ( '>=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:983:19: '>=' + { + match(">="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GREATEREQUAL" + + // $ANTLR start "RIGHTSHIFT" + public final void mRIGHTSHIFT() throws RecognitionException { + try { + int _type = RIGHTSHIFT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:985:15: ( '>>' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:985:17: '>>' + { + match(">>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RIGHTSHIFT" + + // $ANTLR start "PLUSEQUAL" + public final void mPLUSEQUAL() throws RecognitionException { + try { + int _type = PLUSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:987:14: ( '+=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:987:16: '+=' + { + match("+="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PLUSEQUAL" + + // $ANTLR start "MINUSEQUAL" + public final void mMINUSEQUAL() throws RecognitionException { + try { + int _type = MINUSEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:989:15: ( '-=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:989:17: '-=' + { + match("-="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "MINUSEQUAL" + + // $ANTLR start "DOUBLESTAR" + public final void mDOUBLESTAR() throws RecognitionException { + try { + int _type = DOUBLESTAR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:991:15: ( '**' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:991:17: '**' + { + match("**"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESTAR" + + // $ANTLR start "STAREQUAL" + public final void mSTAREQUAL() throws RecognitionException { + try { + int _type = STAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:993:14: ( '*=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:993:16: '*=' + { + match("*="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STAREQUAL" + + // $ANTLR start "DOUBLESLASH" + public final void mDOUBLESLASH() throws RecognitionException { + try { + int _type = DOUBLESLASH; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:995:16: ( '//' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:995:18: '//' + { + match("//"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESLASH" + + // $ANTLR start "SLASHEQUAL" + public final void mSLASHEQUAL() throws RecognitionException { + try { + int _type = SLASHEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:997:15: ( '/=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:997:17: '/=' + { + match("/="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "SLASHEQUAL" + + // $ANTLR start "VBAREQUAL" + public final void mVBAREQUAL() throws RecognitionException { + try { + int _type = VBAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:999:14: ( '|=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:999:16: '|=' + { + match("|="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "VBAREQUAL" + + // $ANTLR start "PERCENTEQUAL" + public final void mPERCENTEQUAL() throws RecognitionException { + try { + int _type = PERCENTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1001:17: ( '%=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1001:19: '%=' + { + match("%="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PERCENTEQUAL" + + // $ANTLR start "AMPEREQUAL" + public final void mAMPEREQUAL() throws RecognitionException { + try { + int _type = AMPEREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1003:15: ( '&=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1003:17: '&=' + { + match("&="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AMPEREQUAL" + + // $ANTLR start "CIRCUMFLEXEQUAL" + public final void mCIRCUMFLEXEQUAL() throws RecognitionException { + try { + int _type = CIRCUMFLEXEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1005:20: ( '^=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1005:22: '^=' + { + match("^="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CIRCUMFLEXEQUAL" + + // $ANTLR start "LEFTSHIFTEQUAL" + public final void mLEFTSHIFTEQUAL() throws RecognitionException { + try { + int _type = LEFTSHIFTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1007:19: ( '<<=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1007:21: '<<=' + { + match("<<="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LEFTSHIFTEQUAL" + + // $ANTLR start "RIGHTSHIFTEQUAL" + public final void mRIGHTSHIFTEQUAL() throws RecognitionException { + try { + int _type = RIGHTSHIFTEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1009:20: ( '>>=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1009:22: '>>=' + { + match(">>="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RIGHTSHIFTEQUAL" + + // $ANTLR start "DOUBLESTAREQUAL" + public final void mDOUBLESTAREQUAL() throws RecognitionException { + try { + int _type = DOUBLESTAREQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1011:20: ( '**=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1011:22: '**=' + { + match("**="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESTAREQUAL" + + // $ANTLR start "DOUBLESLASHEQUAL" + public final void mDOUBLESLASHEQUAL() throws RecognitionException { + try { + int _type = DOUBLESLASHEQUAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1013:21: ( '//=' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1013:23: '//=' + { + match("//="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOUBLESLASHEQUAL" + + // $ANTLR start "DOT" + public final void mDOT() throws RecognitionException { + try { + int _type = DOT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1015:5: ( '.' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1015:7: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "DOT" + + // $ANTLR start "AT" + public final void mAT() throws RecognitionException { + try { + int _type = AT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1017:4: ( '@' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1017:6: '@' + { + match('@'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AT" + + // $ANTLR start "AND" + public final void mAND() throws RecognitionException { + try { + int _type = AND; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1019:5: ( 'and' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1019:7: 'and' + { + match("and"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AND" + + // $ANTLR start "OR" + public final void mOR() throws RecognitionException { + try { + int _type = OR; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1021:4: ( 'or' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1021:6: 'or' + { + match("or"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "OR" + + // $ANTLR start "NOT" + public final void mNOT() throws RecognitionException { + try { + int _type = NOT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1023:5: ( 'not' ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1023:7: 'not' + { + match("not"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NOT" + + // $ANTLR start "FLOAT" + public final void mFLOAT() throws RecognitionException { + try { + int _type = FLOAT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1026:5: ( '.' DIGITS ( Exponent )? | DIGITS '.' Exponent | DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent ) ) + int alt5=3; + alt5 = dfa5.predict(input); + switch (alt5) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1026:9: '.' DIGITS ( Exponent )? + { + match('.'); + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1026:20: ( Exponent )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='E'||LA1_0=='e') ) { + alt1=1; + } + switch (alt1) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1026:21: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1027:9: DIGITS '.' Exponent + { + mDIGITS(); + match('.'); + mExponent(); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:9: DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent ) + { + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:16: ( '.' ( DIGITS ( Exponent )? )? | Exponent ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='.') ) { + alt4=1; + } + else if ( (LA4_0=='E'||LA4_0=='e') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:17: '.' ( DIGITS ( Exponent )? )? + { + match('.'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:21: ( DIGITS ( Exponent )? )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( ((LA3_0>='0' && LA3_0<='9')) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:22: DIGITS ( Exponent )? + { + mDIGITS(); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:29: ( Exponent )? + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='E'||LA2_0=='e') ) { + alt2=1; + } + switch (alt2) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:30: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1028:45: Exponent + { + mExponent(); + + } + break; + + } + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FLOAT" + + // $ANTLR start "LONGINT" + public final void mLONGINT() throws RecognitionException { + try { + int _type = LONGINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1032:5: ( INT ( 'l' | 'L' ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1032:9: INT ( 'l' | 'L' ) + { + mINT(); + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LONGINT" + + // $ANTLR start "Exponent" + public final void mExponent() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1037:5: ( ( 'e' | 'E' ) ( '+' | '-' )? DIGITS ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1037:10: ( 'e' | 'E' ) ( '+' | '-' )? DIGITS + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1037:22: ( '+' | '-' )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='+'||LA6_0=='-') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mDIGITS(); + + } + + } + finally { + } + } + // $ANTLR end "Exponent" + + // $ANTLR start "INT" + public final void mINT() throws RecognitionException { + try { + int _type = INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1040:5: ( '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | '0' ( '0' .. '7' )* | '1' .. '9' ( DIGITS )* ) + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='0') ) { + int LA10_1 = input.LA(2); + + if ( (LA10_1=='X'||LA10_1=='x') ) { + alt10=1; + } + else { + alt10=2;} + } + else if ( ((LA10_0>='1' && LA10_0<='9')) ) { + alt10=3; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1041:9: '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ + { + match('0'); + if ( input.LA(1)=='X'||input.LA(1)=='x' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1041:25: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ + int cnt7=0; + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||(LA7_0>='A' && LA7_0<='F')||(LA7_0>='a' && LA7_0<='f')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt7 >= 1 ) break loop7; + EarlyExitException eee = + new EarlyExitException(7, input); + throw eee; + } + cnt7++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1043:9: '0' ( '0' .. '7' )* + { + match('0'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1043:14: ( '0' .. '7' )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='7')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1043:16: '0' .. '7' + { + matchRange('0','7'); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1044:9: '1' .. '9' ( DIGITS )* + { + matchRange('1','9'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1044:18: ( DIGITS )* + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( ((LA9_0>='0' && LA9_0<='9')) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1044:18: DIGITS + { + mDIGITS(); + + } + break; + + default : + break loop9; + } + } while (true); + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "INT" + + // $ANTLR start "COMPLEX" + public final void mCOMPLEX() throws RecognitionException { + try { + int _type = COMPLEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1048:5: ( ( DIGITS )+ ( 'j' | 'J' ) | FLOAT ( 'j' | 'J' ) ) + int alt12=2; + alt12 = dfa12.predict(input); + switch (alt12) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1048:9: ( DIGITS )+ ( 'j' | 'J' ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1048:9: ( DIGITS )+ + int cnt11=0; + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( ((LA11_0>='0' && LA11_0<='9')) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1048:9: DIGITS + { + mDIGITS(); + + } + break; + + default : + if ( cnt11 >= 1 ) break loop11; + EarlyExitException eee = + new EarlyExitException(11, input); + throw eee; + } + cnt11++; + } while (true); + + if ( input.LA(1)=='J'||input.LA(1)=='j' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1049:9: FLOAT ( 'j' | 'J' ) + { + mFLOAT(); + if ( input.LA(1)=='J'||input.LA(1)=='j' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMPLEX" + + // $ANTLR start "DIGITS" + public final void mDIGITS() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1053:8: ( ( '0' .. '9' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1053:10: ( '0' .. '9' )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1053:10: ( '0' .. '9' )+ + int cnt13=0; + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1053:12: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt13 >= 1 ) break loop13; + EarlyExitException eee = + new EarlyExitException(13, input); + throw eee; + } + cnt13++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "DIGITS" + + // $ANTLR start "NAME" + public final void mNAME() throws RecognitionException { + try { + int _type = NAME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1055:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1055:10: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1056:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop14: + do { + int alt14=2; + int LA14_0 = input.LA(1); + + if ( ((LA14_0>='0' && LA14_0<='9')||(LA14_0>='A' && LA14_0<='Z')||LA14_0=='_'||(LA14_0>='a' && LA14_0<='z')) ) { + alt14=1; + } + + + switch (alt14) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop14; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NAME" + + // $ANTLR start "STRING" + public final void mSTRING() throws RecognitionException { + try { + int _type = STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:5: ( ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:9: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:9: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? + int alt15=9; + alt15 = dfa15.predict(input); + switch (alt15) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:10: 'r' + { + match('r'); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:14: 'u' + { + match('u'); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:18: 'ur' + { + match("ur"); + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:23: 'R' + { + match('R'); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:27: 'U' + { + match('U'); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:31: 'UR' + { + match("UR"); + + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:36: 'uR' + { + match("uR"); + + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1063:41: 'Ur' + { + match("Ur"); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1064:9: ( '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' | '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) + int alt20=4; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='\'') ) { + int LA20_1 = input.LA(2); + + if ( (LA20_1=='\'') ) { + int LA20_3 = input.LA(3); + + if ( (LA20_3=='\'') ) { + alt20=1; + } + else { + alt20=4;} + } + else if ( ((LA20_1>='\u0000' && LA20_1<='\t')||(LA20_1>='\u000B' && LA20_1<='&')||(LA20_1>='(' && LA20_1<='\uFFFF')) ) { + alt20=4; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 20, 1, input); + + throw nvae; + } + } + else if ( (LA20_0=='\"') ) { + int LA20_2 = input.LA(2); + + if ( (LA20_2=='\"') ) { + int LA20_5 = input.LA(3); + + if ( (LA20_5=='\"') ) { + alt20=2; + } + else { + alt20=3;} + } + else if ( ((LA20_2>='\u0000' && LA20_2<='\t')||(LA20_2>='\u000B' && LA20_2<='!')||(LA20_2>='#' && LA20_2<='\uFFFF')) ) { + alt20=3; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 20, 2, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 20, 0, input); + + throw nvae; + } + switch (alt20) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1064:13: '\\'\\'\\'' ( options {greedy=false; } : TRIAPOS )* '\\'\\'\\'' + { + match("'''"); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1064:22: ( options {greedy=false; } : TRIAPOS )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + int LA16_1 = input.LA(2); + + if ( (LA16_1=='\'') ) { + int LA16_3 = input.LA(3); + + if ( (LA16_3=='\'') ) { + alt16=2; + } + else if ( ((LA16_3>='\u0000' && LA16_3<='&')||(LA16_3>='(' && LA16_3<='\uFFFF')) ) { + alt16=1; + } + + + } + else if ( ((LA16_1>='\u0000' && LA16_1<='&')||(LA16_1>='(' && LA16_1<='\uFFFF')) ) { + alt16=1; + } + + + } + else if ( ((LA16_0>='\u0000' && LA16_0<='&')||(LA16_0>='(' && LA16_0<='\uFFFF')) ) { + alt16=1; + } + + + switch (alt16) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1064:47: TRIAPOS + { + mTRIAPOS(); + + } + break; + + default : + break loop16; + } + } while (true); + + match("'''"); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1065:13: '\"\"\"' ( options {greedy=false; } : TRIQUOTE )* '\"\"\"' + { + match("\"\"\""); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1065:19: ( options {greedy=false; } : TRIQUOTE )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0=='\"') ) { + int LA17_1 = input.LA(2); + + if ( (LA17_1=='\"') ) { + int LA17_3 = input.LA(3); + + if ( (LA17_3=='\"') ) { + alt17=2; + } + else if ( ((LA17_3>='\u0000' && LA17_3<='!')||(LA17_3>='#' && LA17_3<='\uFFFF')) ) { + alt17=1; + } + + + } + else if ( ((LA17_1>='\u0000' && LA17_1<='!')||(LA17_1>='#' && LA17_1<='\uFFFF')) ) { + alt17=1; + } + + + } + else if ( ((LA17_0>='\u0000' && LA17_0<='!')||(LA17_0>='#' && LA17_0<='\uFFFF')) ) { + alt17=1; + } + + + switch (alt17) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1065:44: TRIQUOTE + { + mTRIQUOTE(); + + } + break; + + default : + break loop17; + } + } while (true); + + match("\"\"\""); + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1066:13: '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* '\"' + { + match('\"'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1066:17: ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* + loop18: + do { + int alt18=3; + int LA18_0 = input.LA(1); + + if ( (LA18_0=='\\') ) { + alt18=1; + } + else if ( ((LA18_0>='\u0000' && LA18_0<='\t')||(LA18_0>='\u000B' && LA18_0<='!')||(LA18_0>='#' && LA18_0<='[')||(LA18_0>=']' && LA18_0<='\uFFFF')) ) { + alt18=2; + } + + + switch (alt18) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1066:18: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1066:22: ~ ( '\\\\' | '\\n' | '\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop18; + } + } while (true); + + match('\"'); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1067:13: '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' + { + match('\''); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1067:18: ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* + loop19: + do { + int alt19=3; + int LA19_0 = input.LA(1); + + if ( (LA19_0=='\\') ) { + alt19=1; + } + else if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='&')||(LA19_0>='(' && LA19_0<='[')||(LA19_0>=']' && LA19_0<='\uFFFF')) ) { + alt19=2; + } + + + switch (alt19) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1067:19: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1067:23: ~ ( '\\\\' | '\\n' | '\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop19; + } + } while (true); + + match('\''); + + } + break; + + } + + + if (state.tokenStartLine != input.getLine()) { + state.tokenStartLine = input.getLine(); + state.tokenStartCharPositionInLine = -2; + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STRING" + + // $ANTLR start "TRISTRINGPART" + public final void mTRISTRINGPART() throws RecognitionException { + try { + int _type = TRISTRINGPART; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:5: ( ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\\'\\'\\'' (~ ( '\\'\\'\\'' ) )* | '\"\"\"' (~ ( '\"\"\"' ) )* ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:7: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\\'\\'\\'' (~ ( '\\'\\'\\'' ) )* | '\"\"\"' (~ ( '\"\"\"' ) )* ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:7: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? + int alt21=9; + alt21 = dfa21.predict(input); + switch (alt21) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:8: 'r' + { + match('r'); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:12: 'u' + { + match('u'); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:16: 'ur' + { + match("ur"); + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:21: 'R' + { + match('R'); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:25: 'U' + { + match('U'); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:29: 'UR' + { + match("UR"); + + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:34: 'uR' + { + match("uR"); + + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1077:39: 'Ur' + { + match("Ur"); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1078:9: ( '\\'\\'\\'' (~ ( '\\'\\'\\'' ) )* | '\"\"\"' (~ ( '\"\"\"' ) )* ) + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\'') ) { + alt24=1; + } + else if ( (LA24_0=='\"') ) { + alt24=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + + throw nvae; + } + switch (alt24) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1078:13: '\\'\\'\\'' (~ ( '\\'\\'\\'' ) )* + { + match("'''"); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1078:22: (~ ( '\\'\\'\\'' ) )* + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='\u0000' && LA22_0<='\uFFFF')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1078:22: ~ ( '\\'\\'\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop22; + } + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1079:13: '\"\"\"' (~ ( '\"\"\"' ) )* + { + match("\"\"\""); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1079:19: (~ ( '\"\"\"' ) )* + loop23: + do { + int alt23=2; + int LA23_0 = input.LA(1); + + if ( ((LA23_0>='\u0000' && LA23_0<='\uFFFF')) ) { + alt23=1; + } + + + switch (alt23) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1079:19: ~ ( '\"\"\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop23; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "TRISTRINGPART" + + // $ANTLR start "STRINGPART" + public final void mSTRINGPART() throws RecognitionException { + try { + int _type = STRINGPART; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:5: ( ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* CONTINUED_LINE | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* CONTINUED_LINE ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:7: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? ( '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* CONTINUED_LINE | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* CONTINUED_LINE ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:7: ( 'r' | 'u' | 'ur' | 'R' | 'U' | 'UR' | 'uR' | 'Ur' )? + int alt25=9; + alt25 = dfa25.predict(input); + switch (alt25) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:8: 'r' + { + match('r'); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:12: 'u' + { + match('u'); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:16: 'ur' + { + match("ur"); + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:21: 'R' + { + match('R'); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:25: 'U' + { + match('U'); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:29: 'UR' + { + match("UR"); + + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:34: 'uR' + { + match("uR"); + + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1084:39: 'Ur' + { + match("Ur"); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1085:9: ( '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* CONTINUED_LINE | '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* CONTINUED_LINE ) + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0=='\"') ) { + alt28=1; + } + else if ( (LA28_0=='\'') ) { + alt28=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 28, 0, input); + + throw nvae; + } + switch (alt28) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1085:13: '\"' ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* CONTINUED_LINE + { + match('\"'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1085:17: ( ESC | ~ ( '\\\\' | '\\n' | '\"' ) )* + loop26: + do { + int alt26=3; + alt26 = dfa26.predict(input); + switch (alt26) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1085:18: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1085:22: ~ ( '\\\\' | '\\n' | '\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop26; + } + } while (true); + + mCONTINUED_LINE(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1086:13: '\\'' ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* CONTINUED_LINE + { + match('\''); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1086:18: ( ESC | ~ ( '\\\\' | '\\n' | '\\'' ) )* + loop27: + do { + int alt27=3; + alt27 = dfa27.predict(input); + switch (alt27) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1086:19: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1086:23: ~ ( '\\\\' | '\\n' | '\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop27; + } + } while (true); + + mCONTINUED_LINE(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "STRINGPART" + + // $ANTLR start "TRIQUOTE" + public final void mTRIQUOTE() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:5: ( ( '\"' )? ( '\"' )? ( ESC | ~ ( '\\\\' | '\"' ) )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:7: ( '\"' )? ( '\"' )? ( ESC | ~ ( '\\\\' | '\"' ) )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:7: ( '\"' )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0=='\"') ) { + alt29=1; + } + switch (alt29) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:7: '\"' + { + match('\"'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:12: ( '\"' )? + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0=='\"') ) { + alt30=1; + } + switch (alt30) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:12: '\"' + { + match('\"'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:17: ( ESC | ~ ( '\\\\' | '\"' ) )+ + int cnt31=0; + loop31: + do { + int alt31=3; + int LA31_0 = input.LA(1); + + if ( (LA31_0=='\\') ) { + alt31=1; + } + else if ( ((LA31_0>='\u0000' && LA31_0<='!')||(LA31_0>='#' && LA31_0<='[')||(LA31_0>=']' && LA31_0<='\uFFFF')) ) { + alt31=2; + } + + + switch (alt31) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:18: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1094:22: ~ ( '\\\\' | '\"' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt31 >= 1 ) break loop31; + EarlyExitException eee = + new EarlyExitException(31, input); + throw eee; + } + cnt31++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "TRIQUOTE" + + // $ANTLR start "TRIAPOS" + public final void mTRIAPOS() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:5: ( ( '\\'' )? ( '\\'' )? ( ESC | ~ ( '\\\\' | '\\'' ) )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:7: ( '\\'' )? ( '\\'' )? ( ESC | ~ ( '\\\\' | '\\'' ) )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:7: ( '\\'' )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0=='\'') ) { + alt32=1; + } + switch (alt32) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:7: '\\'' + { + match('\''); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:13: ( '\\'' )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0=='\'') ) { + alt33=1; + } + switch (alt33) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:13: '\\'' + { + match('\''); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:19: ( ESC | ~ ( '\\\\' | '\\'' ) )+ + int cnt34=0; + loop34: + do { + int alt34=3; + int LA34_0 = input.LA(1); + + if ( (LA34_0=='\\') ) { + alt34=1; + } + else if ( ((LA34_0>='\u0000' && LA34_0<='&')||(LA34_0>='(' && LA34_0<='[')||(LA34_0>=']' && LA34_0<='\uFFFF')) ) { + alt34=2; + } + + + switch (alt34) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:20: ESC + { + mESC(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1100:24: ~ ( '\\\\' | '\\'' ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt34 >= 1 ) break loop34; + EarlyExitException eee = + new EarlyExitException(34, input); + throw eee; + } + cnt34++; + } while (true); + + + } + + } + finally { + } + } + // $ANTLR end "TRIAPOS" + + // $ANTLR start "ESC" + public final void mESC() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1105:5: ( '\\\\' . ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1105:10: '\\\\' . + { + match('\\'); + matchAny(); + + } + + } + finally { + } + } + // $ANTLR end "ESC" + + // $ANTLR start "CONTINUED_LINE" + public final void mCONTINUED_LINE() throws RecognitionException { + try { + int _type = CONTINUED_LINE; + int _channel = DEFAULT_TOKEN_CHANNEL; + Token nl=null; + + + boolean extraNewlines = false; + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1116:5: ( '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )* ( COMMENT | nl= NEWLINE | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1116:10: '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )* ( COMMENT | nl= NEWLINE | ) + { + match('\\'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1116:15: ( '\\r' )? + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0=='\r') ) { + alt35=1; + } + switch (alt35) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1116:16: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1116:28: ( ' ' | '\\t' )* + loop36: + do { + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0=='\t'||LA36_0==' ') ) { + alt36=1; + } + + + switch (alt36) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop36; + } + } while (true); + + _channel=HIDDEN; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1117:10: ( COMMENT | nl= NEWLINE | ) + int alt37=3; + int LA37_0 = input.LA(1); + + if ( (LA37_0=='\t'||LA37_0==' ') && ((startPos==0))) { + alt37=1; + } + else if ( (LA37_0=='#') ) { + alt37=1; + } + else if ( (LA37_0=='\n'||(LA37_0>='\f' && LA37_0<='\r')) ) { + alt37=2; + } + else { + alt37=3;} + switch (alt37) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1117:12: COMMENT + { + mCOMMENT(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1118:12: nl= NEWLINE + { + int nlStart1929 = getCharIndex(); + mNEWLINE(); + nl = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, nlStart1929, getCharIndex()-1); + + extraNewlines = true; + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1123:10: + { + } + break; + + } + + + if (input.LA(1) == -1) { + if (extraNewlines) { + throw new ParseException("invalid syntax"); + } + emit(new CommonToken(TRAILBACKSLASH,"\\")); + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "CONTINUED_LINE" + + // $ANTLR start "NEWLINE" + public final void mNEWLINE() throws RecognitionException { + try { + int _type = NEWLINE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:5: ( ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:9: ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:9: ( ( '\\u000C' )? ( '\\r' )? '\\n' )+ + int cnt40=0; + loop40: + do { + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0=='\n'||(LA40_0>='\f' && LA40_0<='\r')) ) { + alt40=1; + } + + + switch (alt40) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:10: ( '\\u000C' )? ( '\\r' )? '\\n' + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:10: ( '\\u000C' )? + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0=='\f') ) { + alt38=1; + } + switch (alt38) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:11: '\\u000C' + { + match('\f'); + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:21: ( '\\r' )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0=='\r') ) { + alt39=1; + } + switch (alt39) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1140:22: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + + } + break; + + default : + if ( cnt40 >= 1 ) break loop40; + EarlyExitException eee = + new EarlyExitException(40, input); + throw eee; + } + cnt40++; + } while (true); + + + if ( startPos==0 || implicitLineJoiningLevel>0 ) + _channel=HIDDEN; + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "NEWLINE" + + // $ANTLR start "WS" + public final void mWS() throws RecognitionException { + try { + int _type = WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1146:5: ({...}? => ( ' ' | '\\t' | '\\u000C' )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1146:10: {...}? => ( ' ' | '\\t' | '\\u000C' )+ + { + if ( !((startPos>0)) ) { + throw new FailedPredicateException(input, "WS", "startPos>0"); + } + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1146:26: ( ' ' | '\\t' | '\\u000C' )+ + int cnt41=0; + loop41: + do { + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0=='\t'||LA41_0=='\f'||LA41_0==' ') ) { + alt41=1; + } + + + switch (alt41) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)=='\t'||input.LA(1)=='\f'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt41 >= 1 ) break loop41; + EarlyExitException eee = + new EarlyExitException(41, input); + throw eee; + } + cnt41++; + } while (true); + + _channel=HIDDEN; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "WS" + + // $ANTLR start "LEADING_WS" + public final void mLEADING_WS() throws RecognitionException { + try { + int _type = LEADING_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + + int spaces = 0; + int newlines = 0; + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1160:5: ({...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1160:9: {...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) + { + if ( !((startPos==0)) ) { + throw new FailedPredicateException(input, "LEADING_WS", "startPos==0"); + } + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1161:9: ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==' ') ) { + int LA46_1 = input.LA(2); + + if ( ((implicitLineJoiningLevel>0)) ) { + alt46=1; + } + else if ( (true) ) { + alt46=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 46, 1, input); + + throw nvae; + } + } + else if ( (LA46_0=='\t') ) { + int LA46_2 = input.LA(2); + + if ( ((implicitLineJoiningLevel>0)) ) { + alt46=1; + } + else if ( (true) ) { + alt46=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 46, 2, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 46, 0, input); + + throw nvae; + } + switch (alt46) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1161:13: {...}? ( ' ' | '\\t' )+ + { + if ( !((implicitLineJoiningLevel>0)) ) { + throw new FailedPredicateException(input, "LEADING_WS", "implicitLineJoiningLevel>0"); + } + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1161:43: ( ' ' | '\\t' )+ + int cnt42=0; + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0=='\t'||LA42_0==' ') ) { + alt42=1; + } + + + switch (alt42) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt42 >= 1 ) break loop42; + EarlyExitException eee = + new EarlyExitException(42, input); + throw eee; + } + cnt42++; + } while (true); + + _channel=HIDDEN; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1162:14: ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1162:14: ( ' ' | '\\t' )+ + int cnt43=0; + loop43: + do { + int alt43=3; + int LA43_0 = input.LA(1); + + if ( (LA43_0==' ') ) { + alt43=1; + } + else if ( (LA43_0=='\t') ) { + alt43=2; + } + + + switch (alt43) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1162:20: ' ' + { + match(' '); + spaces++; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1163:19: '\\t' + { + match('\t'); + spaces += 8; spaces -= (spaces % 8); + + } + break; + + default : + if ( cnt43 >= 1 ) break loop43; + EarlyExitException eee = + new EarlyExitException(43, input); + throw eee; + } + cnt43++; + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1165:14: ( ( '\\r' )? '\\n' )* + loop45: + do { + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0=='\n'||LA45_0=='\r') ) { + alt45=1; + } + + + switch (alt45) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1165:16: ( '\\r' )? '\\n' + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1165:16: ( '\\r' )? + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0=='\r') ) { + alt44=1; + } + switch (alt44) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1165:17: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + newlines++; + + } + break; + + default : + break loop45; + } + } while (true); + + + if (input.LA(1) != -1 || newlines == 0) { + // make a string of n spaces where n is column number - 1 + char[] indentation = new char[spaces]; + for (int i=0; i ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ | '#' (~ '\\n' )* ) + int alt51=2; + alt51 = dfa51.predict(input); + switch (alt51) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:10: {...}? => ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ + { + if ( !((startPos==0)) ) { + throw new FailedPredicateException(input, "COMMENT", "startPos==0"); + } + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:27: ( ' ' | '\\t' )* + loop47: + do { + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0=='\t'||LA47_0==' ') ) { + alt47=1; + } + + + switch (alt47) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)=='\t'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop47; + } + } while (true); + + match('#'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:43: (~ '\\n' )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); + + if ( ((LA48_0>='\u0000' && LA48_0<='\t')||(LA48_0>='\u000B' && LA48_0<='\uFFFF')) ) { + alt48=1; + } + + + switch (alt48) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:44: ~ '\\n' + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop48; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:52: ( '\\n' )+ + int cnt49=0; + loop49: + do { + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0=='\n') ) { + alt49=1; + } + + + switch (alt49) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1225:52: '\\n' + { + match('\n'); + + } + break; + + default : + if ( cnt49 >= 1 ) break loop49; + EarlyExitException eee = + new EarlyExitException(49, input); + throw eee; + } + cnt49++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1226:10: '#' (~ '\\n' )* + { + match('#'); + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1226:14: (~ '\\n' )* + loop50: + do { + int alt50=2; + int LA50_0 = input.LA(1); + + if ( ((LA50_0>='\u0000' && LA50_0<='\t')||(LA50_0>='\u000B' && LA50_0<='\uFFFF')) ) { + alt50=1; + } + + + switch (alt50) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1226:15: ~ '\\n' + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop50; + } + } while (true); + + + } + break; + + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "COMMENT" + + public void mTokens() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:8: ( AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD | LPAREN | RPAREN | LBRACK | RBRACK | COLON | COMMA | SEMI | PLUS | MINUS | STAR | SLASH | VBAR | AMPER | LESS | GREATER | ASSIGN | PERCENT | BACKQUOTE | LCURLY | RCURLY | CIRCUMFLEX | TILDE | EQUAL | NOTEQUAL | ALT_NOTEQUAL | LESSEQUAL | LEFTSHIFT | GREATEREQUAL | RIGHTSHIFT | PLUSEQUAL | MINUSEQUAL | DOUBLESTAR | STAREQUAL | DOUBLESLASH | SLASHEQUAL | VBAREQUAL | PERCENTEQUAL | AMPEREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL | DOT | AT | AND | OR | NOT | FLOAT | LONGINT | INT | COMPLEX | NAME | STRING | TRISTRINGPART | STRINGPART | CONTINUED_LINE | NEWLINE | WS | LEADING_WS | COMMENT ) + int alt52=89; + alt52 = dfa52.predict(input); + switch (alt52) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:10: AS + { + mAS(); + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:13: ASSERT + { + mASSERT(); + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:20: BREAK + { + mBREAK(); + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:26: CLASS + { + mCLASS(); + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:32: CONTINUE + { + mCONTINUE(); + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:41: DEF + { + mDEF(); + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:45: DELETE + { + mDELETE(); + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:52: ELIF + { + mELIF(); + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:57: EXCEPT + { + mEXCEPT(); + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:64: EXEC + { + mEXEC(); + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:69: FINALLY + { + mFINALLY(); + + } + break; + case 12 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:77: FROM + { + mFROM(); + + } + break; + case 13 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:82: FOR + { + mFOR(); + + } + break; + case 14 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:86: GLOBAL + { + mGLOBAL(); + + } + break; + case 15 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:93: IF + { + mIF(); + + } + break; + case 16 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:96: IMPORT + { + mIMPORT(); + + } + break; + case 17 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:103: IN + { + mIN(); + + } + break; + case 18 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:106: IS + { + mIS(); + + } + break; + case 19 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:109: LAMBDA + { + mLAMBDA(); + + } + break; + case 20 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:116: ORELSE + { + mORELSE(); + + } + break; + case 21 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:123: PASS + { + mPASS(); + + } + break; + case 22 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:128: PRINT + { + mPRINT(); + + } + break; + case 23 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:134: RAISE + { + mRAISE(); + + } + break; + case 24 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:140: RETURN + { + mRETURN(); + + } + break; + case 25 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:147: TRY + { + mTRY(); + + } + break; + case 26 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:151: WHILE + { + mWHILE(); + + } + break; + case 27 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:157: WITH + { + mWITH(); + + } + break; + case 28 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:162: YIELD + { + mYIELD(); + + } + break; + case 29 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:168: LPAREN + { + mLPAREN(); + + } + break; + case 30 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:175: RPAREN + { + mRPAREN(); + + } + break; + case 31 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:182: LBRACK + { + mLBRACK(); + + } + break; + case 32 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:189: RBRACK + { + mRBRACK(); + + } + break; + case 33 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:196: COLON + { + mCOLON(); + + } + break; + case 34 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:202: COMMA + { + mCOMMA(); + + } + break; + case 35 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:208: SEMI + { + mSEMI(); + + } + break; + case 36 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:213: PLUS + { + mPLUS(); + + } + break; + case 37 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:218: MINUS + { + mMINUS(); + + } + break; + case 38 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:224: STAR + { + mSTAR(); + + } + break; + case 39 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:229: SLASH + { + mSLASH(); + + } + break; + case 40 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:235: VBAR + { + mVBAR(); + + } + break; + case 41 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:240: AMPER + { + mAMPER(); + + } + break; + case 42 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:246: LESS + { + mLESS(); + + } + break; + case 43 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:251: GREATER + { + mGREATER(); + + } + break; + case 44 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:259: ASSIGN + { + mASSIGN(); + + } + break; + case 45 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:266: PERCENT + { + mPERCENT(); + + } + break; + case 46 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:274: BACKQUOTE + { + mBACKQUOTE(); + + } + break; + case 47 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:284: LCURLY + { + mLCURLY(); + + } + break; + case 48 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:291: RCURLY + { + mRCURLY(); + + } + break; + case 49 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:298: CIRCUMFLEX + { + mCIRCUMFLEX(); + + } + break; + case 50 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:309: TILDE + { + mTILDE(); + + } + break; + case 51 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:315: EQUAL + { + mEQUAL(); + + } + break; + case 52 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:321: NOTEQUAL + { + mNOTEQUAL(); + + } + break; + case 53 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:330: ALT_NOTEQUAL + { + mALT_NOTEQUAL(); + + } + break; + case 54 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:343: LESSEQUAL + { + mLESSEQUAL(); + + } + break; + case 55 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:353: LEFTSHIFT + { + mLEFTSHIFT(); + + } + break; + case 56 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:363: GREATEREQUAL + { + mGREATEREQUAL(); + + } + break; + case 57 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:376: RIGHTSHIFT + { + mRIGHTSHIFT(); + + } + break; + case 58 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:387: PLUSEQUAL + { + mPLUSEQUAL(); + + } + break; + case 59 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:397: MINUSEQUAL + { + mMINUSEQUAL(); + + } + break; + case 60 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:408: DOUBLESTAR + { + mDOUBLESTAR(); + + } + break; + case 61 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:419: STAREQUAL + { + mSTAREQUAL(); + + } + break; + case 62 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:429: DOUBLESLASH + { + mDOUBLESLASH(); + + } + break; + case 63 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:441: SLASHEQUAL + { + mSLASHEQUAL(); + + } + break; + case 64 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:452: VBAREQUAL + { + mVBAREQUAL(); + + } + break; + case 65 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:462: PERCENTEQUAL + { + mPERCENTEQUAL(); + + } + break; + case 66 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:475: AMPEREQUAL + { + mAMPEREQUAL(); + + } + break; + case 67 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:486: CIRCUMFLEXEQUAL + { + mCIRCUMFLEXEQUAL(); + + } + break; + case 68 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:502: LEFTSHIFTEQUAL + { + mLEFTSHIFTEQUAL(); + + } + break; + case 69 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:517: RIGHTSHIFTEQUAL + { + mRIGHTSHIFTEQUAL(); + + } + break; + case 70 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:533: DOUBLESTAREQUAL + { + mDOUBLESTAREQUAL(); + + } + break; + case 71 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:549: DOUBLESLASHEQUAL + { + mDOUBLESLASHEQUAL(); + + } + break; + case 72 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:566: DOT + { + mDOT(); + + } + break; + case 73 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:570: AT + { + mAT(); + + } + break; + case 74 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:573: AND + { + mAND(); + + } + break; + case 75 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:577: OR + { + mOR(); + + } + break; + case 76 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:580: NOT + { + mNOT(); + + } + break; + case 77 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:584: FLOAT + { + mFLOAT(); + + } + break; + case 78 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:590: LONGINT + { + mLONGINT(); + + } + break; + case 79 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:598: INT + { + mINT(); + + } + break; + case 80 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:602: COMPLEX + { + mCOMPLEX(); + + } + break; + case 81 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:610: NAME + { + mNAME(); + + } + break; + case 82 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:615: STRING + { + mSTRING(); + + } + break; + case 83 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:622: TRISTRINGPART + { + mTRISTRINGPART(); + + } + break; + case 84 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:636: STRINGPART + { + mSTRINGPART(); + + } + break; + case 85 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:647: CONTINUED_LINE + { + mCONTINUED_LINE(); + + } + break; + case 86 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:662: NEWLINE + { + mNEWLINE(); + + } + break; + case 87 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:670: WS + { + mWS(); + + } + break; + case 88 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:673: LEADING_WS + { + mLEADING_WS(); + + } + break; + case 89 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:1:684: COMMENT + { + mCOMMENT(); + + } + break; + + } + + } + + + protected DFA5 dfa5 = new DFA5(this); + protected DFA12 dfa12 = new DFA12(this); + protected DFA15 dfa15 = new DFA15(this); + protected DFA21 dfa21 = new DFA21(this); + protected DFA25 dfa25 = new DFA25(this); + protected DFA26 dfa26 = new DFA26(this); + protected DFA27 dfa27 = new DFA27(this); + protected DFA51 dfa51 = new DFA51(this); + protected DFA52 dfa52 = new DFA52(this); + static final String DFA5_eotS = + "\3\uffff\1\4\2\uffff"; + static final String DFA5_eofS = + "\6\uffff"; + static final String DFA5_minS = + "\1\56\1\uffff\1\56\1\105\2\uffff"; + static final String DFA5_maxS = + "\1\71\1\uffff\2\145\2\uffff"; + static final String DFA5_acceptS = + "\1\uffff\1\1\2\uffff\1\3\1\2"; + static final String DFA5_specialS = + "\6\uffff}>"; + static final String[] DFA5_transitionS = { + "\1\1\1\uffff\12\2", + "", + "\1\3\1\uffff\12\2\13\uffff\1\4\37\uffff\1\4", + "\1\5\37\uffff\1\5", + "", + "" + }; + + static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS); + static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS); + static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS); + static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS); + static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS); + static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS); + static final short[][] DFA5_transition; + + static { + int numStates = DFA5_transitionS.length; + DFA5_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA12_transitionS = { + "\1\2\1\uffff\12\1", + "\1\2\1\uffff\12\1\13\uffff\1\2\4\uffff\1\3\32\uffff\1\2\4\uffff"+ + "\1\3", + "", + "" + }; + + static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); + static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); + static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); + static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); + static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); + static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); + static final short[][] DFA12_transition; + + static { + int numStates = DFA12_transitionS.length; + DFA12_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA15_transitionS = { + "\1\5\4\uffff\1\5\52\uffff\1\3\2\uffff\1\4\34\uffff\1\1\2\uffff"+ + "\1\2", + "", + "\1\10\4\uffff\1\10\52\uffff\1\7\37\uffff\1\6", + "", + "\1\13\4\uffff\1\13\52\uffff\1\11\37\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS); + static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS); + static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS); + static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS); + static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS); + static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS); + static final short[][] DFA15_transition; + + static { + int numStates = DFA15_transitionS.length; + DFA15_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA21_transitionS = { + "\1\5\4\uffff\1\5\52\uffff\1\3\2\uffff\1\4\34\uffff\1\1\2\uffff"+ + "\1\2", + "", + "\1\10\4\uffff\1\10\52\uffff\1\7\37\uffff\1\6", + "", + "\1\13\4\uffff\1\13\52\uffff\1\11\37\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS); + static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS); + static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS); + static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS); + static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS); + static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS); + static final short[][] DFA21_transition; + + static { + int numStates = DFA21_transitionS.length; + DFA21_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA25_transitionS = { + "\1\5\4\uffff\1\5\52\uffff\1\3\2\uffff\1\4\34\uffff\1\1\2\uffff"+ + "\1\2", + "", + "\1\10\4\uffff\1\10\52\uffff\1\7\37\uffff\1\6", + "", + "\1\13\4\uffff\1\13\52\uffff\1\11\37\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA25_eot = DFA.unpackEncodedString(DFA25_eotS); + static final short[] DFA25_eof = DFA.unpackEncodedString(DFA25_eofS); + static final char[] DFA25_min = DFA.unpackEncodedStringToUnsignedChars(DFA25_minS); + static final char[] DFA25_max = DFA.unpackEncodedStringToUnsignedChars(DFA25_maxS); + static final short[] DFA25_accept = DFA.unpackEncodedString(DFA25_acceptS); + static final short[] DFA25_special = DFA.unpackEncodedString(DFA25_specialS); + static final short[][] DFA25_transition; + + static { + int numStates = DFA25_transitionS.length; + DFA25_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA26_transitionS = { + "\12\2\1\uffff\27\2\1\uffff\71\2\1\1\uffa3\2", + "\12\5\1\4\2\5\1\3\ufff2\5", + "", + "\12\5\1\6\27\5\1\uffff\uffdd\5", + "\11\5\1\7\1\uffff\1\5\1\11\1\12\22\5\1\7\1\5\1\uffff\1\10\uffdc"+ + "\5", + "", + "", + "\11\5\1\7\1\uffff\1\5\1\11\1\12\22\5\1\7\1\5\1\uffff\1\10\uffdc"+ + "\5", + "\12\14\1\uffff\27\14\1\uffff\71\14\1\13\uffa3\14", + "\12\5\1\6\2\5\1\12\24\5\1\uffff\uffdd\5", + "\12\5\1\6\27\5\1\uffff\uffdd\5", + "\12\17\1\16\2\17\1\15\ufff2\17", + "\12\14\1\uffff\27\14\1\uffff\71\14\1\13\uffa3\14", + "\12\14\1\20\27\14\1\uffff\71\14\1\13\uffa3\14", + "", + "\12\14\1\uffff\27\14\1\uffff\71\14\1\13\uffa3\14", + "" + }; + + static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS); + static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS); + static final char[] DFA26_min = DFA.unpackEncodedStringToUnsignedChars(DFA26_minS); + static final char[] DFA26_max = DFA.unpackEncodedStringToUnsignedChars(DFA26_maxS); + static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS); + static final short[] DFA26_special = DFA.unpackEncodedString(DFA26_specialS); + static final short[][] DFA26_transition; + + static { + int numStates = DFA26_transitionS.length; + DFA26_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA26_1<='\t')||(LA26_1>='\u000B' && LA26_1<='\f')||(LA26_1>='\u000E' && LA26_1<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA26_3 = input.LA(1); + + s = -1; + if ( ((LA26_3>='\u0000' && LA26_3<='\t')||(LA26_3>='\u000B' && LA26_3<='!')||(LA26_3>='#' && LA26_3<='\uFFFF')) ) {s = 5;} + + else if ( (LA26_3=='\n') ) {s = 6;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA26_11 = input.LA(1); + + s = -1; + if ( (LA26_11=='\r') ) {s = 13;} + + else if ( (LA26_11=='\n') ) {s = 14;} + + else if ( ((LA26_11>='\u0000' && LA26_11<='\t')||(LA26_11>='\u000B' && LA26_11<='\f')||(LA26_11>='\u000E' && LA26_11<='\uFFFF')) ) {s = 15;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 3 : + int LA26_4 = input.LA(1); + + s = -1; + if ( ((LA26_4>='\u0000' && LA26_4<='\b')||LA26_4=='\u000B'||(LA26_4>='\u000E' && LA26_4<='\u001F')||LA26_4=='!'||(LA26_4>='$' && LA26_4<='\uFFFF')) ) {s = 5;} + + else if ( (LA26_4=='\t'||LA26_4==' ') ) {s = 7;} + + else if ( (LA26_4=='#') ) {s = 8;} + + else if ( (LA26_4=='\f') ) {s = 9;} + + else if ( (LA26_4=='\r') ) {s = 10;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 4 : + int LA26_15 = input.LA(1); + + s = -1; + if ( (LA26_15=='\\') ) {s = 11;} + + else if ( ((LA26_15>='\u0000' && LA26_15<='\t')||(LA26_15>='\u000B' && LA26_15<='!')||(LA26_15>='#' && LA26_15<='[')||(LA26_15>=']' && LA26_15<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 5 : + int LA26_13 = input.LA(1); + + s = -1; + if ( (LA26_13=='\\') ) {s = 11;} + + else if ( ((LA26_13>='\u0000' && LA26_13<='\t')||(LA26_13>='\u000B' && LA26_13<='!')||(LA26_13>='#' && LA26_13<='[')||(LA26_13>=']' && LA26_13<='\uFFFF')) ) {s = 12;} + + else if ( (LA26_13=='\n') ) {s = 16;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 6 : + int LA26_0 = input.LA(1); + + s = -1; + if ( (LA26_0=='\\') ) {s = 1;} + + else if ( ((LA26_0>='\u0000' && LA26_0<='\t')||(LA26_0>='\u000B' && LA26_0<='!')||(LA26_0>='#' && LA26_0<='[')||(LA26_0>=']' && LA26_0<='\uFFFF')) ) {s = 2;} + + if ( s>=0 ) return s; + break; + case 7 : + int LA26_10 = input.LA(1); + + s = -1; + if ( (LA26_10=='\n') ) {s = 6;} + + else if ( ((LA26_10>='\u0000' && LA26_10<='\t')||(LA26_10>='\u000B' && LA26_10<='!')||(LA26_10>='#' && LA26_10<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA26_8 = input.LA(1); + + s = -1; + if ( (LA26_8=='\\') ) {s = 11;} + + else if ( ((LA26_8>='\u0000' && LA26_8<='\t')||(LA26_8>='\u000B' && LA26_8<='!')||(LA26_8>='#' && LA26_8<='[')||(LA26_8>=']' && LA26_8<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 9 : + int LA26_12 = input.LA(1); + + s = -1; + if ( (LA26_12=='\\') ) {s = 11;} + + else if ( ((LA26_12>='\u0000' && LA26_12<='\t')||(LA26_12>='\u000B' && LA26_12<='!')||(LA26_12>='#' && LA26_12<='[')||(LA26_12>=']' && LA26_12<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 10 : + int LA26_7 = input.LA(1); + + s = -1; + if ( (LA26_7=='#') ) {s = 8;} + + else if ( (LA26_7=='\t'||LA26_7==' ') ) {s = 7;} + + else if ( (LA26_7=='\f') ) {s = 9;} + + else if ( (LA26_7=='\r') ) {s = 10;} + + else if ( ((LA26_7>='\u0000' && LA26_7<='\b')||LA26_7=='\u000B'||(LA26_7>='\u000E' && LA26_7<='\u001F')||LA26_7=='!'||(LA26_7>='$' && LA26_7<='\uFFFF')) ) {s = 5;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 11 : + int LA26_9 = input.LA(1); + + s = -1; + if ( (LA26_9=='\r') ) {s = 10;} + + else if ( (LA26_9=='\n') ) {s = 6;} + + else if ( ((LA26_9>='\u0000' && LA26_9<='\t')||(LA26_9>='\u000B' && LA26_9<='\f')||(LA26_9>='\u000E' && LA26_9<='!')||(LA26_9>='#' && LA26_9<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 26, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA27_eotS = + "\4\uffff\1\6\2\uffff\2\6\2\uffff\3\6\1\uffff\1\6\1\uffff"; + static final String DFA27_eofS = + "\21\uffff"; + static final String DFA27_minS = + "\2\0\1\uffff\2\0\2\uffff\7\0\1\uffff\1\0\1\uffff"; + static final String DFA27_maxS = + "\2\uffff\1\uffff\2\uffff\2\uffff\7\uffff\1\uffff\1\uffff\1\uffff"; + static final String DFA27_acceptS = + "\2\uffff\1\2\2\uffff\1\1\1\3\7\uffff\1\1\1\uffff\1\1"; + static final String DFA27_specialS = + "\1\0\1\1\1\uffff\1\7\1\3\2\uffff\1\13\1\10\1\4\1\2\1\12\1\11\1\6"+ + "\1\uffff\1\5\1\uffff}>"; + static final String[] DFA27_transitionS = { + "\12\2\1\uffff\34\2\1\uffff\64\2\1\1\uffa3\2", + "\12\5\1\4\2\5\1\3\ufff2\5", + "", + "\12\5\1\6\34\5\1\uffff\uffd8\5", + "\11\5\1\7\1\uffff\1\5\1\11\1\12\22\5\1\7\2\5\1\10\3\5\1\uffff"+ + "\uffd8\5", + "", + "", + "\11\5\1\7\1\uffff\1\5\1\11\1\12\22\5\1\7\2\5\1\10\3\5\1\uffff"+ + "\uffd8\5", + "\12\14\1\uffff\34\14\1\uffff\64\14\1\13\uffa3\14", + "\12\5\1\6\2\5\1\12\31\5\1\uffff\uffd8\5", + "\12\5\1\6\34\5\1\uffff\uffd8\5", + "\12\17\1\16\2\17\1\15\ufff2\17", + "\12\14\1\uffff\34\14\1\uffff\64\14\1\13\uffa3\14", + "\12\14\1\20\34\14\1\uffff\64\14\1\13\uffa3\14", + "", + "\12\14\1\uffff\34\14\1\uffff\64\14\1\13\uffa3\14", + "" + }; + + static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS); + static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS); + static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS); + static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS); + static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS); + static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS); + static final short[][] DFA27_transition; + + static { + int numStates = DFA27_transitionS.length; + DFA27_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA27_0<='\t')||(LA27_0>='\u000B' && LA27_0<='&')||(LA27_0>='(' && LA27_0<='[')||(LA27_0>=']' && LA27_0<='\uFFFF')) ) {s = 2;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA27_1 = input.LA(1); + + s = -1; + if ( (LA27_1=='\r') ) {s = 3;} + + else if ( (LA27_1=='\n') ) {s = 4;} + + else if ( ((LA27_1>='\u0000' && LA27_1<='\t')||(LA27_1>='\u000B' && LA27_1<='\f')||(LA27_1>='\u000E' && LA27_1<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA27_10 = input.LA(1); + + s = -1; + if ( (LA27_10=='\n') ) {s = 6;} + + else if ( ((LA27_10>='\u0000' && LA27_10<='\t')||(LA27_10>='\u000B' && LA27_10<='&')||(LA27_10>='(' && LA27_10<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + case 3 : + int LA27_4 = input.LA(1); + + s = -1; + if ( ((LA27_4>='\u0000' && LA27_4<='\b')||LA27_4=='\u000B'||(LA27_4>='\u000E' && LA27_4<='\u001F')||(LA27_4>='!' && LA27_4<='\"')||(LA27_4>='$' && LA27_4<='&')||(LA27_4>='(' && LA27_4<='\uFFFF')) ) {s = 5;} + + else if ( (LA27_4=='\t'||LA27_4==' ') ) {s = 7;} + + else if ( (LA27_4=='#') ) {s = 8;} + + else if ( (LA27_4=='\f') ) {s = 9;} + + else if ( (LA27_4=='\r') ) {s = 10;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 4 : + int LA27_9 = input.LA(1); + + s = -1; + if ( (LA27_9=='\r') ) {s = 10;} + + else if ( (LA27_9=='\n') ) {s = 6;} + + else if ( ((LA27_9>='\u0000' && LA27_9<='\t')||(LA27_9>='\u000B' && LA27_9<='\f')||(LA27_9>='\u000E' && LA27_9<='&')||(LA27_9>='(' && LA27_9<='\uFFFF')) ) {s = 5;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA27_15 = input.LA(1); + + s = -1; + if ( (LA27_15=='\\') ) {s = 11;} + + else if ( ((LA27_15>='\u0000' && LA27_15<='\t')||(LA27_15>='\u000B' && LA27_15<='&')||(LA27_15>='(' && LA27_15<='[')||(LA27_15>=']' && LA27_15<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 6 : + int LA27_13 = input.LA(1); + + s = -1; + if ( (LA27_13=='\\') ) {s = 11;} + + else if ( ((LA27_13>='\u0000' && LA27_13<='\t')||(LA27_13>='\u000B' && LA27_13<='&')||(LA27_13>='(' && LA27_13<='[')||(LA27_13>=']' && LA27_13<='\uFFFF')) ) {s = 12;} + + else if ( (LA27_13=='\n') ) {s = 16;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 7 : + int LA27_3 = input.LA(1); + + s = -1; + if ( ((LA27_3>='\u0000' && LA27_3<='\t')||(LA27_3>='\u000B' && LA27_3<='&')||(LA27_3>='(' && LA27_3<='\uFFFF')) ) {s = 5;} + + else if ( (LA27_3=='\n') ) {s = 6;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA27_8 = input.LA(1); + + s = -1; + if ( (LA27_8=='\\') ) {s = 11;} + + else if ( ((LA27_8>='\u0000' && LA27_8<='\t')||(LA27_8>='\u000B' && LA27_8<='&')||(LA27_8>='(' && LA27_8<='[')||(LA27_8>=']' && LA27_8<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 9 : + int LA27_12 = input.LA(1); + + s = -1; + if ( (LA27_12=='\\') ) {s = 11;} + + else if ( ((LA27_12>='\u0000' && LA27_12<='\t')||(LA27_12>='\u000B' && LA27_12<='&')||(LA27_12>='(' && LA27_12<='[')||(LA27_12>=']' && LA27_12<='\uFFFF')) ) {s = 12;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 10 : + int LA27_11 = input.LA(1); + + s = -1; + if ( (LA27_11=='\r') ) {s = 13;} + + else if ( (LA27_11=='\n') ) {s = 14;} + + else if ( ((LA27_11>='\u0000' && LA27_11<='\t')||(LA27_11>='\u000B' && LA27_11<='\f')||(LA27_11>='\u000E' && LA27_11<='\uFFFF')) ) {s = 15;} + + else s = 6; + + if ( s>=0 ) return s; + break; + case 11 : + int LA27_7 = input.LA(1); + + s = -1; + if ( (LA27_7=='#') ) {s = 8;} + + else if ( (LA27_7=='\t'||LA27_7==' ') ) {s = 7;} + + else if ( (LA27_7=='\f') ) {s = 9;} + + else if ( (LA27_7=='\r') ) {s = 10;} + + else if ( ((LA27_7>='\u0000' && LA27_7<='\b')||LA27_7=='\u000B'||(LA27_7>='\u000E' && LA27_7<='\u001F')||(LA27_7>='!' && LA27_7<='\"')||(LA27_7>='$' && LA27_7<='&')||(LA27_7>='(' && LA27_7<='\uFFFF')) ) {s = 5;} + + else s = 6; + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 27, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA51_eotS = + "\2\uffff\2\4\1\uffff"; + static final String DFA51_eofS = + "\5\uffff"; + static final String DFA51_minS = + "\1\11\1\uffff\2\0\1\uffff"; + static final String DFA51_maxS = + "\1\43\1\uffff\2\uffff\1\uffff"; + static final String DFA51_acceptS = + "\1\uffff\1\1\2\uffff\1\2"; + static final String DFA51_specialS = + "\1\2\1\uffff\1\0\1\1\1\uffff}>"; + static final String[] DFA51_transitionS = { + "\1\1\26\uffff\1\1\2\uffff\1\2", + "", + "\12\3\1\1\ufff5\3", + "\12\3\1\1\ufff5\3", + "" + }; + + static final short[] DFA51_eot = DFA.unpackEncodedString(DFA51_eotS); + static final short[] DFA51_eof = DFA.unpackEncodedString(DFA51_eofS); + static final char[] DFA51_min = DFA.unpackEncodedStringToUnsignedChars(DFA51_minS); + static final char[] DFA51_max = DFA.unpackEncodedStringToUnsignedChars(DFA51_maxS); + static final short[] DFA51_accept = DFA.unpackEncodedString(DFA51_acceptS); + static final short[] DFA51_special = DFA.unpackEncodedString(DFA51_specialS); + static final short[][] DFA51_transition; + + static { + int numStates = DFA51_transitionS.length; + DFA51_transition = new short[numStates][]; + for (int i=0; i ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ | '#' (~ '\\n' )* );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + IntStream input = _input; + int _s = s; + switch ( s ) { + case 0 : + int LA51_2 = input.LA(1); + + + int index51_2 = input.index(); + input.rewind(); + s = -1; + if ( ((LA51_2>='\u0000' && LA51_2<='\t')||(LA51_2>='\u000B' && LA51_2<='\uFFFF')) ) {s = 3;} + + else if ( (LA51_2=='\n') && ((startPos==0))) {s = 1;} + + else s = 4; + + + input.seek(index51_2); + if ( s>=0 ) return s; + break; + case 1 : + int LA51_3 = input.LA(1); + + + int index51_3 = input.index(); + input.rewind(); + s = -1; + if ( ((LA51_3>='\u0000' && LA51_3<='\t')||(LA51_3>='\u000B' && LA51_3<='\uFFFF')) ) {s = 3;} + + else if ( (LA51_3=='\n') && ((startPos==0))) {s = 1;} + + else s = 4; + + + input.seek(index51_3); + if ( s>=0 ) return s; + break; + case 2 : + int LA51_0 = input.LA(1); + + + int index51_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA51_0=='\t'||LA51_0==' ') && ((startPos==0))) {s = 1;} + + else if ( (LA51_0=='#') ) {s = 2;} + + + input.seek(index51_0); + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 51, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA52_eotS = + "\1\uffff\16\57\7\uffff\1\122\1\124\1\127\1\132\1\134\1\136\1\142"+ + "\1\145\1\147\1\151\3\uffff\1\153\2\uffff\1\154\1\uffff\2\57\2\161"+ + "\3\57\4\uffff\1\u0083\1\uffff\1\u0085\1\u0087\1\uffff\1\u0089\13"+ + "\57\1\u0098\1\57\1\u009a\1\u009b\11\57\4\uffff\1\u00a6\2\uffff\1"+ + "\u00a8\10\uffff\1\u00aa\2\uffff\1\u00ac\10\uffff\1\u00ad\1\u00af"+ + "\1\57\2\uffff\1\u00ad\1\uffff\1\161\3\uffff\1\161\4\57\1\u00b7\2"+ + "\uffff\1\u00b7\7\uffff\1\57\1\uffff\1\u00c0\3\57\1\u00c4\1\u00c5"+ + "\6\57\1\u00cc\1\57\1\uffff\1\57\2\uffff\5\57\1\u00d4\3\57\13\uffff"+ + "\1\u00da\1\161\1\uffff\1\u00ad\1\uffff\1\u00ad\1\u00e1\2\uffff\1"+ + "\u00e2\1\uffff\1\u00e1\1\uffff\1\u00e2\1\uffff\1\57\1\uffff\3\57"+ + "\2\uffff\1\u00f2\1\u00f3\1\57\1\u00f5\1\57\1\u00f7\1\uffff\3\57"+ + "\1\u00fb\3\57\1\uffff\1\57\1\u0100\1\57\1\uffff\1\u00ad\2\uffff"+ + "\1\u00ad\1\uffff\3\u00e1\2\uffff\2\u00e2\2\uffff\3\u00e1\2\u00e2"+ + "\2\uffff\1\57\1\u010f\1\u0110\1\57\2\uffff\1\57\1\uffff\1\57\1\uffff"+ + "\3\57\1\uffff\1\u0117\1\u0118\1\57\1\u011a\1\uffff\1\u011b\1\uffff"+ + "\1\u00ad\2\u00e1\1\u00b7\2\u00e2\2\u00e1\1\u00b7\2\u00e2\1\u0124"+ + "\2\uffff\1\57\1\u0126\1\57\1\u0128\1\u0129\1\u012a\2\uffff\1\u012b"+ + "\2\uffff\1\u00b7\3\u00e2\1\u00b7\3\u00e2\1\uffff\1\57\1\uffff\1"+ + "\u012d\4\uffff\1\u012e\2\uffff"; + static final String DFA52_eofS = + "\u012f\uffff"; + static final String DFA52_minS = + "\1\11\1\156\1\162\1\154\1\145\1\154\1\151\1\154\1\146\2\141\1\42"+ + "\1\162\1\150\1\151\7\uffff\2\75\1\52\1\57\2\75\1\74\3\75\3\uffff"+ + "\1\75\2\uffff\1\60\1\uffff\1\162\1\157\2\56\3\42\1\uffff\2\0\1\uffff"+ + "\1\12\1\uffff\2\11\1\uffff\1\60\1\144\1\145\1\141\1\156\1\146\1"+ + "\151\1\143\1\156\1\157\1\162\1\157\1\60\1\160\2\60\1\155\1\163\2"+ + "\151\1\164\1\171\1\151\1\164\1\145\4\uffff\1\75\2\uffff\1\75\10"+ + "\uffff\1\75\2\uffff\1\75\10\uffff\2\60\1\164\1\60\1\uffff\1\60\1"+ + "\53\2\56\2\uffff\1\56\4\42\1\47\2\0\1\42\2\0\2\uffff\1\0\1\uffff"+ + "\1\0\1\145\1\uffff\1\60\1\141\1\163\1\164\2\60\1\146\2\145\1\143"+ + "\1\141\1\155\1\60\1\142\1\uffff\1\157\2\uffff\1\142\1\163\1\156"+ + "\1\163\1\165\1\60\1\154\1\150\1\154\11\uffff\1\53\1\uffff\2\60\1"+ + "\53\3\60\1\0\1\uffff\7\0\1\162\1\uffff\1\153\1\163\1\151\2\uffff"+ + "\2\60\1\160\1\60\1\154\1\60\1\uffff\1\141\1\162\1\144\1\60\1\164"+ + "\1\145\1\162\1\uffff\1\145\1\60\1\144\2\60\1\uffff\2\60\1\53\3\0"+ + "\2\uffff\13\0\1\164\2\60\1\156\2\uffff\1\164\1\uffff\1\154\1\uffff"+ + "\1\154\1\164\1\141\1\uffff\2\60\1\156\1\60\1\uffff\3\60\12\0\1\60"+ + "\2\uffff\1\165\1\60\1\171\3\60\2\uffff\1\60\2\uffff\10\0\1\uffff"+ + "\1\145\1\uffff\1\60\4\uffff\1\60\2\uffff"; + static final String DFA52_maxS = + "\1\176\1\163\1\162\1\157\1\145\1\170\1\162\1\154\1\163\1\141\1\162"+ + "\1\145\1\162\2\151\7\uffff\6\75\2\76\2\75\3\uffff\1\75\2\uffff\1"+ + "\71\1\uffff\1\162\1\157\1\170\1\154\1\162\1\47\1\162\1\uffff\2\uffff"+ + "\1\uffff\1\15\1\uffff\2\43\1\uffff\1\172\1\144\1\145\1\141\1\156"+ + "\1\154\1\163\1\145\1\156\1\157\1\162\1\157\1\172\1\160\2\172\1\155"+ + "\1\163\2\151\1\164\1\171\1\151\1\164\1\145\4\uffff\1\75\2\uffff"+ + "\1\75\10\uffff\1\75\2\uffff\1\75\10\uffff\1\152\1\172\1\164\1\146"+ + "\1\uffff\1\152\1\71\1\154\1\152\2\uffff\1\154\5\47\2\uffff\1\42"+ + "\2\uffff\2\uffff\1\0\1\uffff\1\0\1\145\1\uffff\1\172\1\141\1\163"+ + "\1\164\2\172\1\146\2\145\1\143\1\141\1\155\1\172\1\142\1\uffff\1"+ + "\157\2\uffff\1\142\1\163\1\156\1\163\1\165\1\172\1\154\1\150\1\154"+ + "\11\uffff\1\71\1\uffff\1\172\1\154\1\71\1\152\1\71\1\152\1\uffff"+ + "\1\uffff\7\uffff\1\162\1\uffff\1\153\1\163\1\151\2\uffff\2\172\1"+ + "\160\1\172\1\154\1\172\1\uffff\1\141\1\162\1\144\1\172\1\164\1\145"+ + "\1\162\1\uffff\1\145\1\172\1\144\1\71\1\152\1\uffff\1\71\1\152\1"+ + "\71\3\uffff\2\uffff\13\uffff\1\164\2\172\1\156\2\uffff\1\164\1\uffff"+ + "\1\154\1\uffff\1\154\1\164\1\141\1\uffff\2\172\1\156\1\172\1\uffff"+ + "\1\172\1\71\1\152\12\uffff\1\172\2\uffff\1\165\1\172\1\171\3\172"+ + "\2\uffff\1\172\2\uffff\10\uffff\1\uffff\1\145\1\uffff\1\172\4\uffff"+ + "\1\172\2\uffff"; + static final String DFA52_acceptS = + "\17\uffff\1\35\1\36\1\37\1\40\1\41\1\42\1\43\12\uffff\1\56\1\57"+ + "\1\60\1\uffff\1\62\1\64\1\uffff\1\111\7\uffff\1\121\2\uffff\1\125"+ + "\1\uffff\1\126\2\uffff\1\131\31\uffff\1\72\1\44\1\73\1\45\1\uffff"+ + "\1\75\1\46\1\uffff\1\77\1\47\1\100\1\50\1\102\1\51\1\65\1\66\1\uffff"+ + "\1\52\1\70\1\uffff\1\53\1\63\1\54\1\101\1\55\1\103\1\61\1\110\4"+ + "\uffff\1\117\4\uffff\1\116\1\120\13\uffff\1\127\1\131\1\uffff\1"+ + "\130\2\uffff\1\1\16\uffff\1\17\1\uffff\1\21\1\22\11\uffff\1\106"+ + "\1\74\1\107\1\76\1\104\1\67\1\105\1\71\1\115\1\uffff\1\113\7\uffff"+ + "\1\122\10\uffff\1\112\3\uffff\1\6\1\7\6\uffff\1\15\7\uffff\1\31"+ + "\5\uffff\1\114\6\uffff\1\123\1\124\17\uffff\1\10\1\24\1\uffff\1"+ + "\12\1\uffff\1\14\3\uffff\1\25\4\uffff\1\33\16\uffff\1\3\1\4\6\uffff"+ + "\1\26\1\27\1\uffff\1\32\1\34\10\uffff\1\2\1\uffff\1\11\1\uffff\1"+ + "\16\1\20\1\23\1\30\1\uffff\1\13\1\5"; + static final String DFA52_specialS = + "\1\55\57\uffff\1\44\1\17\1\uffff\1\13\1\uffff\1\14\1\15\107\uffff"+ + "\1\0\1\6\1\uffff\1\1\1\34\2\uffff\1\56\1\uffff\1\57\56\uffff\1\2"+ + "\1\uffff\1\5\1\11\1\3\1\40\1\33\1\36\1\32\37\uffff\1\26\1\51\1\54"+ + "\2\uffff\1\21\1\43\1\30\1\12\1\10\1\63\1\25\1\52\1\16\1\4\1\41\26"+ + "\uffff\1\35\1\24\1\60\1\42\1\47\1\31\1\53\1\50\1\37\1\23\16\uffff"+ + "\1\61\1\46\1\62\1\45\1\7\1\22\1\27\1\20\13\uffff}>"; + static final String[] DFA52_transitionS = { + "\1\66\1\64\1\uffff\1\63\1\64\22\uffff\1\65\1\45\1\61\1\67\1"+ + "\uffff\1\37\1\33\1\60\1\17\1\20\1\30\1\26\1\24\1\27\1\46\1\31"+ + "\1\52\11\53\1\23\1\25\1\34\1\36\1\35\1\uffff\1\47\21\57\1\55"+ + "\2\57\1\56\5\57\1\21\1\62\1\22\1\43\1\57\1\40\1\1\1\2\1\3\1"+ + "\4\1\5\1\6\1\7\1\57\1\10\2\57\1\11\1\57\1\51\1\50\1\12\1\57"+ + "\1\13\1\57\1\14\1\54\1\57\1\15\1\57\1\16\1\57\1\41\1\32\1\42"+ + "\1\44", + "\1\71\4\uffff\1\70", + "\1\72", + "\1\73\2\uffff\1\74", + "\1\75", + "\1\76\13\uffff\1\77", + "\1\100\5\uffff\1\102\2\uffff\1\101", + "\1\103", + "\1\104\6\uffff\1\105\1\106\4\uffff\1\107", + "\1\110", + "\1\111\20\uffff\1\112", + "\1\61\4\uffff\1\60\71\uffff\1\113\3\uffff\1\114", + "\1\115", + "\1\116\1\117", + "\1\120", + "", + "", + "", + "", + "", + "", + "", + "\1\121", + "\1\123", + "\1\125\22\uffff\1\126", + "\1\130\15\uffff\1\131", + "\1\133", + "\1\135", + "\1\141\1\140\1\137", + "\1\143\1\144", + "\1\146", + "\1\150", + "", + "", + "", + "\1\152", + "", + "", + "\12\155", + "", + "\1\156", + "\1\157", + "\1\162\1\uffff\10\164\2\165\13\uffff\1\163\4\uffff\1\167\1"+ + "\uffff\1\166\13\uffff\1\160\14\uffff\1\163\4\uffff\1\167\1\uffff"+ + "\1\166\13\uffff\1\160", + "\1\162\1\uffff\12\170\13\uffff\1\163\4\uffff\1\167\1\uffff"+ + "\1\166\30\uffff\1\163\4\uffff\1\167\1\uffff\1\166", + "\1\61\4\uffff\1\60\52\uffff\1\172\37\uffff\1\171", + "\1\61\4\uffff\1\60", + "\1\61\4\uffff\1\60\52\uffff\1\173\37\uffff\1\174", + "", + "\12\177\1\uffff\34\177\1\175\64\177\1\176\uffa3\177", + "\12\u0082\1\uffff\27\u0082\1\u0080\71\u0082\1\u0081\uffa3\u0082", + "", + "\1\64\2\uffff\1\64", + "", + "\1\66\1\u0086\1\uffff\1\u0083\1\u0086\22\uffff\1\65\2\uffff"+ + "\1\u0084", + "\1\66\1\u0086\1\uffff\1\u0083\1\u0086\22\uffff\1\65\2\uffff"+ + "\1\u0084", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0088\7\57", + "\1\u008a", + "\1\u008b", + "\1\u008c", + "\1\u008d", + "\1\u008e\5\uffff\1\u008f", + "\1\u0090\11\uffff\1\u0091", + "\1\u0092\1\uffff\1\u0093", + "\1\u0094", + "\1\u0095", + "\1\u0096", + "\1\u0097", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u0099", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u009c", + "\1\u009d", + "\1\u009e", + "\1\u009f", + "\1\u00a0", + "\1\u00a1", + "\1\u00a2", + "\1\u00a3", + "\1\u00a4", + "", + "", + "", + "", + "\1\u00a5", + "", + "", + "\1\u00a7", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\u00a9", + "", + "", + "\1\u00ab", + "", + "", + "", + "", + "", + "", + "", + "", + "\12\155\13\uffff\1\u00ae\4\uffff\1\167\32\uffff\1\u00ae\4\uffff"+ + "\1\167", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00b0", + "\12\u00b1\7\uffff\6\u00b1\32\uffff\6\u00b1", + "", + "\12\u00b3\13\uffff\1\u00b2\4\uffff\1\167\32\uffff\1\u00b2\4"+ + "\uffff\1\167", + "\1\u00b4\1\uffff\1\u00b4\2\uffff\12\u00b5", + "\1\162\1\uffff\10\164\2\165\13\uffff\1\163\4\uffff\1\167\1"+ + "\uffff\1\166\30\uffff\1\163\4\uffff\1\167\1\uffff\1\166", + "\1\162\1\uffff\12\165\13\uffff\1\163\4\uffff\1\167\32\uffff"+ + "\1\163\4\uffff\1\167", + "", + "", + "\1\162\1\uffff\12\170\13\uffff\1\163\4\uffff\1\167\1\uffff"+ + "\1\166\30\uffff\1\163\4\uffff\1\167\1\uffff\1\166", + "\1\61\4\uffff\1\60", + "\1\61\4\uffff\1\60", + "\1\61\4\uffff\1\60", + "\1\61\4\uffff\1\60", + "\1\u00b6", + "\12\u00ba\1\u00b9\2\u00ba\1\u00b8\ufff2\u00ba", + "\12\177\1\uffff\34\177\1\u00b7\64\177\1\176\uffa3\177", + "\1\u00bb", + "\12\u00be\1\u00bd\2\u00be\1\u00bc\ufff2\u00be", + "\12\u0082\1\uffff\27\u0082\1\u00b7\71\u0082\1\u0081\uffa3\u0082", + "", + "", + "\1\uffff", + "", + "\1\uffff", + "\1\u00bf", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00c1", + "\1\u00c2", + "\1\u00c3", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00c6", + "\1\u00c7", + "\1\u00c8", + "\1\u00c9", + "\1\u00ca", + "\1\u00cb", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00cd", + "", + "\1\u00ce", + "", + "", + "\1\u00cf", + "\1\u00d0", + "\1\u00d1", + "\1\u00d2", + "\1\u00d3", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00d5", + "\1\u00d6", + "\1\u00d7", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\u00d8\1\uffff\1\u00d8\2\uffff\12\u00d9", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\u00b1\7\uffff\6\u00b1\5\uffff\1\166\24\uffff\6\u00b1\5"+ + "\uffff\1\166", + "\1\u00db\1\uffff\1\u00db\2\uffff\12\u00dc", + "\12\u00b3\13\uffff\1\u00dd\4\uffff\1\167\32\uffff\1\u00dd\4"+ + "\uffff\1\167", + "\12\u00b5", + "\12\u00b5\20\uffff\1\167\37\uffff\1\167", + "\47\u00e0\1\u00de\64\u00e0\1\u00df\uffa3\u00e0", + "", + "\12\177\1\u00e2\34\177\1\u00b7\64\177\1\176\uffa3\177", + "\11\177\1\u00e3\1\uffff\1\177\1\u00e5\1\u00e6\22\177\1\u00e3"+ + "\2\177\1\u00e4\3\177\1\u00b7\64\177\1\176\uffa3\177", + "\12\177\1\uffff\34\177\1\u00b7\64\177\1\176\uffa3\177", + "\42\u00e9\1\u00e7\71\u00e9\1\u00e8\uffa3\u00e9", + "\12\u0082\1\u00e2\27\u0082\1\u00b7\71\u0082\1\u0081\uffa3\u0082", + "\11\u0082\1\u00ea\1\uffff\1\u0082\1\u00ec\1\u00ed\22\u0082"+ + "\1\u00ea\1\u0082\1\u00b7\1\u00eb\70\u0082\1\u0081\uffa3\u0082", + "\12\u0082\1\uffff\27\u0082\1\u00b7\71\u0082\1\u0081\uffa3\u0082", + "\1\u00ee", + "", + "\1\u00ef", + "\1\u00f0", + "\1\u00f1", + "", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00f4", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00f6", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\u00f8", + "\1\u00f9", + "\1\u00fa", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u00fc", + "\1\u00fd", + "\1\u00fe", + "", + "\1\u00ff", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u0101", + "\12\u00d9", + "\12\u00d9\20\uffff\1\167\37\uffff\1\167", + "", + "\12\u00dc", + "\12\u00dc\20\uffff\1\167\37\uffff\1\167", + "\1\u0102\1\uffff\1\u0102\2\uffff\12\u0103", + "\47\u00e0\1\u0104\64\u00e0\1\u00df\uffa3\u00e0", + "\0\u0105", + "\47\u00e0\1\u00de\64\u00e0\1\u00df\uffa3\u00e0", + "", + "", + "\11\177\1\u00e3\1\uffff\1\177\1\u00e5\1\u00e6\22\177\1\u00e3"+ + "\2\177\1\u00e4\3\177\1\u00b7\64\177\1\176\uffa3\177", + "\12\u0108\1\uffff\34\u0108\1\u0106\64\u0108\1\u0107\uffa3\u0108", + "\12\177\1\u00e2\2\177\1\u00e6\31\177\1\u00b7\64\177\1\176\uffa3"+ + "\177", + "\12\177\1\u00e2\34\177\1\u00b7\64\177\1\176\uffa3\177", + "\42\u00e9\1\u0109\71\u00e9\1\u00e8\uffa3\u00e9", + "\0\u010a", + "\42\u00e9\1\u00e7\71\u00e9\1\u00e8\uffa3\u00e9", + "\11\u0082\1\u00ea\1\uffff\1\u0082\1\u00ec\1\u00ed\22\u0082"+ + "\1\u00ea\1\u0082\1\u00b7\1\u00eb\70\u0082\1\u0081\uffa3\u0082", + "\12\u010d\1\uffff\27\u010d\1\u010b\71\u010d\1\u010c\uffa3\u010d", + "\12\u0082\1\u00e2\2\u0082\1\u00ed\24\u0082\1\u00b7\71\u0082"+ + "\1\u0081\uffa3\u0082", + "\12\u0082\1\u00e2\27\u0082\1\u00b7\71\u0082\1\u0081\uffa3\u0082", + "\1\u010e", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u0111", + "", + "", + "\1\u0112", + "", + "\1\u0113", + "", + "\1\u0114", + "\1\u0115", + "\1\u0116", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u0119", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\u0103", + "\12\u0103\20\uffff\1\167\37\uffff\1\167", + "\47\u00e0\1\u011c\64\u00e0\1\u00df\uffa3\u00e0", + "\47\u00e0\1\u00de\64\u00e0\1\u00df\uffa3\u00e0", + "\0\u00e2", + "\12\u011f\1\u011e\2\u011f\1\u011d\ufff2\u011f", + "\12\u0108\1\uffff\34\u0108\1\u0106\64\u0108\1\u0107\uffa3\u0108", + "\42\u00e9\1\u0120\71\u00e9\1\u00e8\uffa3\u00e9", + "\42\u00e9\1\u00e7\71\u00e9\1\u00e8\uffa3\u00e9", + "\0\u00e2", + "\12\u0123\1\u0122\2\u0123\1\u0121\ufff2\u0123", + "\12\u010d\1\uffff\27\u010d\1\u010b\71\u010d\1\u010c\uffa3\u010d", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\u0125", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\u0127", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\0\u00e1", + "\12\u0108\1\uffff\34\u0108\1\u0106\64\u0108\1\u0107\uffa3\u0108", + "\11\177\1\u00e3\1\uffff\1\177\1\u00e5\1\u00e6\22\177\1\u00e3"+ + "\2\177\1\u00e4\3\177\1\u00b7\64\177\1\176\uffa3\177", + "\12\u0108\1\uffff\34\u0108\1\u0106\64\u0108\1\u0107\uffa3\u0108", + "\0\u00e1", + "\12\u010d\1\uffff\27\u010d\1\u010b\71\u010d\1\u010c\uffa3\u010d", + "\11\u0082\1\u00ea\1\uffff\1\u0082\1\u00ec\1\u00ed\22\u0082"+ + "\1\u00ea\1\u0082\1\u00b7\1\u00eb\70\u0082\1\u0081\uffa3\u0082", + "\12\u010d\1\uffff\27\u010d\1\u010b\71\u010d\1\u010c\uffa3\u010d", + "", + "\1\u012c", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "" + }; + + static final short[] DFA52_eot = DFA.unpackEncodedString(DFA52_eotS); + static final short[] DFA52_eof = DFA.unpackEncodedString(DFA52_eofS); + static final char[] DFA52_min = DFA.unpackEncodedStringToUnsignedChars(DFA52_minS); + static final char[] DFA52_max = DFA.unpackEncodedStringToUnsignedChars(DFA52_maxS); + static final short[] DFA52_accept = DFA.unpackEncodedString(DFA52_acceptS); + static final short[] DFA52_special = DFA.unpackEncodedString(DFA52_specialS); + static final short[][] DFA52_transition; + + static { + int numStates = DFA52_transitionS.length; + DFA52_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA52_126<='\t')||(LA52_126>='\u000B' && LA52_126<='\f')||(LA52_126>='\u000E' && LA52_126<='\uFFFF')) ) {s = 186;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA52_129 = input.LA(1); + + s = -1; + if ( (LA52_129=='\r') ) {s = 188;} + + else if ( (LA52_129=='\n') ) {s = 189;} + + else if ( ((LA52_129>='\u0000' && LA52_129<='\t')||(LA52_129>='\u000B' && LA52_129<='\f')||(LA52_129>='\u000E' && LA52_129<='\uFFFF')) ) {s = 190;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA52_182 = input.LA(1); + + s = -1; + if ( (LA52_182=='\'') ) {s = 222;} + + else if ( (LA52_182=='\\') ) {s = 223;} + + else if ( ((LA52_182>='\u0000' && LA52_182<='&')||(LA52_182>='(' && LA52_182<='[')||(LA52_182>=']' && LA52_182<='\uFFFF')) ) {s = 224;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 3 : + int LA52_186 = input.LA(1); + + s = -1; + if ( (LA52_186=='\'') ) {s = 183;} + + else if ( (LA52_186=='\\') ) {s = 126;} + + else if ( ((LA52_186>='\u0000' && LA52_186<='\t')||(LA52_186>='\u000B' && LA52_186<='&')||(LA52_186>='(' && LA52_186<='[')||(LA52_186>=']' && LA52_186<='\uFFFF')) ) {s = 127;} + + if ( s>=0 ) return s; + break; + case 4 : + int LA52_236 = input.LA(1); + + s = -1; + if ( (LA52_236=='\"') ) {s = 183;} + + else if ( (LA52_236=='\\') ) {s = 129;} + + else if ( (LA52_236=='\r') ) {s = 237;} + + else if ( ((LA52_236>='\u0000' && LA52_236<='\t')||(LA52_236>='\u000B' && LA52_236<='\f')||(LA52_236>='\u000E' && LA52_236<='!')||(LA52_236>='#' && LA52_236<='[')||(LA52_236>=']' && LA52_236<='\uFFFF')) ) {s = 130;} + + else if ( (LA52_236=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA52_184 = input.LA(1); + + s = -1; + if ( (LA52_184=='\'') ) {s = 183;} + + else if ( (LA52_184=='\\') ) {s = 126;} + + else if ( ((LA52_184>='\u0000' && LA52_184<='\t')||(LA52_184>='\u000B' && LA52_184<='&')||(LA52_184>='(' && LA52_184<='[')||(LA52_184>=']' && LA52_184<='\uFFFF')) ) {s = 127;} + + else if ( (LA52_184=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA52_127 = input.LA(1); + + s = -1; + if ( (LA52_127=='\'') ) {s = 183;} + + else if ( (LA52_127=='\\') ) {s = 126;} + + else if ( ((LA52_127>='\u0000' && LA52_127<='\t')||(LA52_127>='\u000B' && LA52_127<='&')||(LA52_127>='(' && LA52_127<='[')||(LA52_127>=']' && LA52_127<='\uFFFF')) ) {s = 127;} + + if ( s>=0 ) return s; + break; + case 7 : + int LA52_288 = input.LA(1); + + s = -1; + if ( ((LA52_288>='\u0000' && LA52_288<='\uFFFF')) ) {s = 225;} + + else s = 183; + + if ( s>=0 ) return s; + break; + case 8 : + int LA52_231 = input.LA(1); + + s = -1; + if ( (LA52_231=='\"') ) {s = 265;} + + else if ( (LA52_231=='\\') ) {s = 232;} + + else if ( ((LA52_231>='\u0000' && LA52_231<='!')||(LA52_231>='#' && LA52_231<='[')||(LA52_231>=']' && LA52_231<='\uFFFF')) ) {s = 233;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 9 : + int LA52_185 = input.LA(1); + + s = -1; + if ( (LA52_185=='\t'||LA52_185==' ') ) {s = 227;} + + else if ( (LA52_185=='#') ) {s = 228;} + + else if ( (LA52_185=='\f') ) {s = 229;} + + else if ( (LA52_185=='\r') ) {s = 230;} + + else if ( (LA52_185=='\'') ) {s = 183;} + + else if ( (LA52_185=='\\') ) {s = 126;} + + else if ( ((LA52_185>='\u0000' && LA52_185<='\b')||LA52_185=='\u000B'||(LA52_185>='\u000E' && LA52_185<='\u001F')||(LA52_185>='!' && LA52_185<='\"')||(LA52_185>='$' && LA52_185<='&')||(LA52_185>='(' && LA52_185<='[')||(LA52_185>=']' && LA52_185<='\uFFFF')) ) {s = 127;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 10 : + int LA52_230 = input.LA(1); + + s = -1; + if ( (LA52_230=='\'') ) {s = 183;} + + else if ( (LA52_230=='\\') ) {s = 126;} + + else if ( ((LA52_230>='\u0000' && LA52_230<='\t')||(LA52_230>='\u000B' && LA52_230<='&')||(LA52_230>='(' && LA52_230<='[')||(LA52_230>=']' && LA52_230<='\uFFFF')) ) {s = 127;} + + else if ( (LA52_230=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 11 : + int LA52_51 = input.LA(1); + + + int index52_51 = input.index(); + input.rewind(); + s = -1; + if ( (LA52_51=='\n'||LA52_51=='\r') ) {s = 52;} + + else s = 131; + + + input.seek(index52_51); + if ( s>=0 ) return s; + break; + case 12 : + int LA52_53 = input.LA(1); + + + int index52_53 = input.index(); + input.rewind(); + s = -1; + if ( (LA52_53=='#') && ((startPos==0))) {s = 132;} + + else if ( (LA52_53==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA52_53=='\f') && ((startPos>0))) {s = 131;} + + else if ( (LA52_53=='\n'||LA52_53=='\r') && ((startPos==0))) {s = 134;} + + else if ( (LA52_53=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else s = 133; + + + input.seek(index52_53); + if ( s>=0 ) return s; + break; + case 13 : + int LA52_54 = input.LA(1); + + + int index52_54 = input.index(); + input.rewind(); + s = -1; + if ( (LA52_54=='#') && ((startPos==0))) {s = 132;} + + else if ( (LA52_54==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA52_54=='\f') && ((startPos>0))) {s = 131;} + + else if ( (LA52_54=='\n'||LA52_54=='\r') && ((startPos==0))) {s = 134;} + + else if ( (LA52_54=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else s = 135; + + + input.seek(index52_54); + if ( s>=0 ) return s; + break; + case 14 : + int LA52_235 = input.LA(1); + + s = -1; + if ( (LA52_235=='\"') ) {s = 267;} + + else if ( (LA52_235=='\\') ) {s = 268;} + + else if ( ((LA52_235>='\u0000' && LA52_235<='\t')||(LA52_235>='\u000B' && LA52_235<='!')||(LA52_235>='#' && LA52_235<='[')||(LA52_235>=']' && LA52_235<='\uFFFF')) ) {s = 269;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 15 : + int LA52_49 = input.LA(1); + + s = -1; + if ( (LA52_49=='\"') ) {s = 128;} + + else if ( (LA52_49=='\\') ) {s = 129;} + + else if ( ((LA52_49>='\u0000' && LA52_49<='\t')||(LA52_49>='\u000B' && LA52_49<='!')||(LA52_49>='#' && LA52_49<='[')||(LA52_49>=']' && LA52_49<='\uFFFF')) ) {s = 130;} + + if ( s>=0 ) return s; + break; + case 16 : + int LA52_291 = input.LA(1); + + s = -1; + if ( (LA52_291=='\"') ) {s = 267;} + + else if ( (LA52_291=='\\') ) {s = 268;} + + else if ( ((LA52_291>='\u0000' && LA52_291<='\t')||(LA52_291>='\u000B' && LA52_291<='!')||(LA52_291>='#' && LA52_291<='[')||(LA52_291>=']' && LA52_291<='\uFFFF')) ) {s = 269;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 17 : + int LA52_227 = input.LA(1); + + s = -1; + if ( (LA52_227=='#') ) {s = 228;} + + else if ( (LA52_227=='\t'||LA52_227==' ') ) {s = 227;} + + else if ( (LA52_227=='\'') ) {s = 183;} + + else if ( (LA52_227=='\\') ) {s = 126;} + + else if ( (LA52_227=='\f') ) {s = 229;} + + else if ( (LA52_227=='\r') ) {s = 230;} + + else if ( ((LA52_227>='\u0000' && LA52_227<='\b')||LA52_227=='\u000B'||(LA52_227>='\u000E' && LA52_227<='\u001F')||(LA52_227>='!' && LA52_227<='\"')||(LA52_227>='$' && LA52_227<='&')||(LA52_227>='(' && LA52_227<='[')||(LA52_227>=']' && LA52_227<='\uFFFF')) ) {s = 127;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 18 : + int LA52_289 = input.LA(1); + + s = -1; + if ( (LA52_289=='\"') ) {s = 267;} + + else if ( (LA52_289=='\\') ) {s = 268;} + + else if ( ((LA52_289>='\u0000' && LA52_289<='\t')||(LA52_289>='\u000B' && LA52_289<='!')||(LA52_289>='#' && LA52_289<='[')||(LA52_289>=']' && LA52_289<='\uFFFF')) ) {s = 269;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 19 : + int LA52_269 = input.LA(1); + + s = -1; + if ( (LA52_269=='\"') ) {s = 267;} + + else if ( (LA52_269=='\\') ) {s = 268;} + + else if ( ((LA52_269>='\u0000' && LA52_269<='\t')||(LA52_269>='\u000B' && LA52_269<='!')||(LA52_269>='#' && LA52_269<='[')||(LA52_269>=']' && LA52_269<='\uFFFF')) ) {s = 269;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 20 : + int LA52_261 = input.LA(1); + + s = -1; + if ( (LA52_261=='\'') ) {s = 222;} + + else if ( (LA52_261=='\\') ) {s = 223;} + + else if ( ((LA52_261>='\u0000' && LA52_261<='&')||(LA52_261>='(' && LA52_261<='[')||(LA52_261>=']' && LA52_261<='\uFFFF')) ) {s = 224;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 21 : + int LA52_233 = input.LA(1); + + s = -1; + if ( (LA52_233=='\"') ) {s = 231;} + + else if ( (LA52_233=='\\') ) {s = 232;} + + else if ( ((LA52_233>='\u0000' && LA52_233<='!')||(LA52_233>='#' && LA52_233<='[')||(LA52_233>=']' && LA52_233<='\uFFFF')) ) {s = 233;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 22 : + int LA52_222 = input.LA(1); + + s = -1; + if ( (LA52_222=='\'') ) {s = 260;} + + else if ( (LA52_222=='\\') ) {s = 223;} + + else if ( ((LA52_222>='\u0000' && LA52_222<='&')||(LA52_222>='(' && LA52_222<='[')||(LA52_222>=']' && LA52_222<='\uFFFF')) ) {s = 224;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 23 : + int LA52_290 = input.LA(1); + + s = -1; + if ( (LA52_290=='\t'||LA52_290==' ') ) {s = 234;} + + else if ( (LA52_290=='#') ) {s = 235;} + + else if ( (LA52_290=='\f') ) {s = 236;} + + else if ( (LA52_290=='\r') ) {s = 237;} + + else if ( (LA52_290=='\"') ) {s = 183;} + + else if ( (LA52_290=='\\') ) {s = 129;} + + else if ( ((LA52_290>='\u0000' && LA52_290<='\b')||LA52_290=='\u000B'||(LA52_290>='\u000E' && LA52_290<='\u001F')||LA52_290=='!'||(LA52_290>='$' && LA52_290<='[')||(LA52_290>=']' && LA52_290<='\uFFFF')) ) {s = 130;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 24 : + int LA52_229 = input.LA(1); + + s = -1; + if ( (LA52_229=='\'') ) {s = 183;} + + else if ( (LA52_229=='\\') ) {s = 126;} + + else if ( (LA52_229=='\r') ) {s = 230;} + + else if ( ((LA52_229>='\u0000' && LA52_229<='\t')||(LA52_229>='\u000B' && LA52_229<='\f')||(LA52_229>='\u000E' && LA52_229<='&')||(LA52_229>='(' && LA52_229<='[')||(LA52_229>=']' && LA52_229<='\uFFFF')) ) {s = 127;} + + else if ( (LA52_229=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 25 : + int LA52_265 = input.LA(1); + + s = -1; + if ( (LA52_265=='\"') ) {s = 288;} + + else if ( (LA52_265=='\\') ) {s = 232;} + + else if ( ((LA52_265>='\u0000' && LA52_265<='!')||(LA52_265>='#' && LA52_265<='[')||(LA52_265>=']' && LA52_265<='\uFFFF')) ) {s = 233;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 26 : + int LA52_190 = input.LA(1); + + s = -1; + if ( (LA52_190=='\"') ) {s = 183;} + + else if ( (LA52_190=='\\') ) {s = 129;} + + else if ( ((LA52_190>='\u0000' && LA52_190<='\t')||(LA52_190>='\u000B' && LA52_190<='!')||(LA52_190>='#' && LA52_190<='[')||(LA52_190>=']' && LA52_190<='\uFFFF')) ) {s = 130;} + + if ( s>=0 ) return s; + break; + case 27 : + int LA52_188 = input.LA(1); + + s = -1; + if ( (LA52_188=='\"') ) {s = 183;} + + else if ( (LA52_188=='\\') ) {s = 129;} + + else if ( ((LA52_188>='\u0000' && LA52_188<='\t')||(LA52_188>='\u000B' && LA52_188<='!')||(LA52_188>='#' && LA52_188<='[')||(LA52_188>=']' && LA52_188<='\uFFFF')) ) {s = 130;} + + else if ( (LA52_188=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 28 : + int LA52_130 = input.LA(1); + + s = -1; + if ( (LA52_130=='\"') ) {s = 183;} + + else if ( (LA52_130=='\\') ) {s = 129;} + + else if ( ((LA52_130>='\u0000' && LA52_130<='\t')||(LA52_130>='\u000B' && LA52_130<='!')||(LA52_130>='#' && LA52_130<='[')||(LA52_130>=']' && LA52_130<='\uFFFF')) ) {s = 130;} + + if ( s>=0 ) return s; + break; + case 29 : + int LA52_260 = input.LA(1); + + s = -1; + if ( (LA52_260=='\'') ) {s = 284;} + + else if ( (LA52_260=='\\') ) {s = 223;} + + else if ( ((LA52_260>='\u0000' && LA52_260<='&')||(LA52_260>='(' && LA52_260<='[')||(LA52_260>=']' && LA52_260<='\uFFFF')) ) {s = 224;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 30 : + int LA52_189 = input.LA(1); + + s = -1; + if ( (LA52_189=='\t'||LA52_189==' ') ) {s = 234;} + + else if ( (LA52_189=='#') ) {s = 235;} + + else if ( (LA52_189=='\f') ) {s = 236;} + + else if ( (LA52_189=='\r') ) {s = 237;} + + else if ( (LA52_189=='\"') ) {s = 183;} + + else if ( (LA52_189=='\\') ) {s = 129;} + + else if ( ((LA52_189>='\u0000' && LA52_189<='\b')||LA52_189=='\u000B'||(LA52_189>='\u000E' && LA52_189<='\u001F')||LA52_189=='!'||(LA52_189>='$' && LA52_189<='[')||(LA52_189>=']' && LA52_189<='\uFFFF')) ) {s = 130;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 31 : + int LA52_268 = input.LA(1); + + s = -1; + if ( (LA52_268=='\r') ) {s = 289;} + + else if ( (LA52_268=='\n') ) {s = 290;} + + else if ( ((LA52_268>='\u0000' && LA52_268<='\t')||(LA52_268>='\u000B' && LA52_268<='\f')||(LA52_268>='\u000E' && LA52_268<='\uFFFF')) ) {s = 291;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 32 : + int LA52_187 = input.LA(1); + + s = -1; + if ( (LA52_187=='\"') ) {s = 231;} + + else if ( (LA52_187=='\\') ) {s = 232;} + + else if ( ((LA52_187>='\u0000' && LA52_187<='!')||(LA52_187>='#' && LA52_187<='[')||(LA52_187>=']' && LA52_187<='\uFFFF')) ) {s = 233;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 33 : + int LA52_237 = input.LA(1); + + s = -1; + if ( (LA52_237=='\"') ) {s = 183;} + + else if ( (LA52_237=='\\') ) {s = 129;} + + else if ( ((LA52_237>='\u0000' && LA52_237<='\t')||(LA52_237>='\u000B' && LA52_237<='!')||(LA52_237>='#' && LA52_237<='[')||(LA52_237>=']' && LA52_237<='\uFFFF')) ) {s = 130;} + + else if ( (LA52_237=='\n') ) {s = 226;} + + if ( s>=0 ) return s; + break; + case 34 : + int LA52_263 = input.LA(1); + + s = -1; + if ( (LA52_263=='\r') ) {s = 285;} + + else if ( (LA52_263=='\n') ) {s = 286;} + + else if ( ((LA52_263>='\u0000' && LA52_263<='\t')||(LA52_263>='\u000B' && LA52_263<='\f')||(LA52_263>='\u000E' && LA52_263<='\uFFFF')) ) {s = 287;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 35 : + int LA52_228 = input.LA(1); + + s = -1; + if ( (LA52_228=='\'') ) {s = 262;} + + else if ( (LA52_228=='\\') ) {s = 263;} + + else if ( ((LA52_228>='\u0000' && LA52_228<='\t')||(LA52_228>='\u000B' && LA52_228<='&')||(LA52_228>='(' && LA52_228<='[')||(LA52_228>=']' && LA52_228<='\uFFFF')) ) {s = 264;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 36 : + int LA52_48 = input.LA(1); + + s = -1; + if ( (LA52_48=='\'') ) {s = 125;} + + else if ( (LA52_48=='\\') ) {s = 126;} + + else if ( ((LA52_48>='\u0000' && LA52_48<='\t')||(LA52_48>='\u000B' && LA52_48<='&')||(LA52_48>='(' && LA52_48<='[')||(LA52_48>=']' && LA52_48<='\uFFFF')) ) {s = 127;} + + if ( s>=0 ) return s; + break; + case 37 : + int LA52_287 = input.LA(1); + + s = -1; + if ( (LA52_287=='\'') ) {s = 262;} + + else if ( (LA52_287=='\\') ) {s = 263;} + + else if ( ((LA52_287>='\u0000' && LA52_287<='\t')||(LA52_287>='\u000B' && LA52_287<='&')||(LA52_287>='(' && LA52_287<='[')||(LA52_287>=']' && LA52_287<='\uFFFF')) ) {s = 264;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 38 : + int LA52_285 = input.LA(1); + + s = -1; + if ( (LA52_285=='\'') ) {s = 262;} + + else if ( (LA52_285=='\\') ) {s = 263;} + + else if ( ((LA52_285>='\u0000' && LA52_285<='\t')||(LA52_285>='\u000B' && LA52_285<='&')||(LA52_285>='(' && LA52_285<='[')||(LA52_285>=']' && LA52_285<='\uFFFF')) ) {s = 264;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 39 : + int LA52_264 = input.LA(1); + + s = -1; + if ( (LA52_264=='\'') ) {s = 262;} + + else if ( (LA52_264=='\\') ) {s = 263;} + + else if ( ((LA52_264>='\u0000' && LA52_264<='\t')||(LA52_264>='\u000B' && LA52_264<='&')||(LA52_264>='(' && LA52_264<='[')||(LA52_264>=']' && LA52_264<='\uFFFF')) ) {s = 264;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 40 : + int LA52_267 = input.LA(1); + + s = -1; + if ( ((LA52_267>='\u0000' && LA52_267<='\uFFFF')) ) {s = 226;} + + else s = 183; + + if ( s>=0 ) return s; + break; + case 41 : + int LA52_223 = input.LA(1); + + s = -1; + if ( ((LA52_223>='\u0000' && LA52_223<='\uFFFF')) ) {s = 261;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 42 : + int LA52_234 = input.LA(1); + + s = -1; + if ( (LA52_234=='#') ) {s = 235;} + + else if ( (LA52_234=='\t'||LA52_234==' ') ) {s = 234;} + + else if ( (LA52_234=='\"') ) {s = 183;} + + else if ( (LA52_234=='\\') ) {s = 129;} + + else if ( (LA52_234=='\f') ) {s = 236;} + + else if ( (LA52_234=='\r') ) {s = 237;} + + else if ( ((LA52_234>='\u0000' && LA52_234<='\b')||LA52_234=='\u000B'||(LA52_234>='\u000E' && LA52_234<='\u001F')||LA52_234=='!'||(LA52_234>='$' && LA52_234<='[')||(LA52_234>=']' && LA52_234<='\uFFFF')) ) {s = 130;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 43 : + int LA52_266 = input.LA(1); + + s = -1; + if ( (LA52_266=='\"') ) {s = 231;} + + else if ( (LA52_266=='\\') ) {s = 232;} + + else if ( ((LA52_266>='\u0000' && LA52_266<='!')||(LA52_266>='#' && LA52_266<='[')||(LA52_266>=']' && LA52_266<='\uFFFF')) ) {s = 233;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 44 : + int LA52_224 = input.LA(1); + + s = -1; + if ( (LA52_224=='\'') ) {s = 222;} + + else if ( (LA52_224=='\\') ) {s = 223;} + + else if ( ((LA52_224>='\u0000' && LA52_224<='&')||(LA52_224>='(' && LA52_224<='[')||(LA52_224>=']' && LA52_224<='\uFFFF')) ) {s = 224;} + + else s = 225; + + if ( s>=0 ) return s; + break; + case 45 : + int LA52_0 = input.LA(1); + + + int index52_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA52_0=='a') ) {s = 1;} + + else if ( (LA52_0=='b') ) {s = 2;} + + else if ( (LA52_0=='c') ) {s = 3;} + + else if ( (LA52_0=='d') ) {s = 4;} + + else if ( (LA52_0=='e') ) {s = 5;} + + else if ( (LA52_0=='f') ) {s = 6;} + + else if ( (LA52_0=='g') ) {s = 7;} + + else if ( (LA52_0=='i') ) {s = 8;} + + else if ( (LA52_0=='l') ) {s = 9;} + + else if ( (LA52_0=='p') ) {s = 10;} + + else if ( (LA52_0=='r') ) {s = 11;} + + else if ( (LA52_0=='t') ) {s = 12;} + + else if ( (LA52_0=='w') ) {s = 13;} + + else if ( (LA52_0=='y') ) {s = 14;} + + else if ( (LA52_0=='(') ) {s = 15;} + + else if ( (LA52_0==')') ) {s = 16;} + + else if ( (LA52_0=='[') ) {s = 17;} + + else if ( (LA52_0==']') ) {s = 18;} + + else if ( (LA52_0==':') ) {s = 19;} + + else if ( (LA52_0==',') ) {s = 20;} + + else if ( (LA52_0==';') ) {s = 21;} + + else if ( (LA52_0=='+') ) {s = 22;} + + else if ( (LA52_0=='-') ) {s = 23;} + + else if ( (LA52_0=='*') ) {s = 24;} + + else if ( (LA52_0=='/') ) {s = 25;} + + else if ( (LA52_0=='|') ) {s = 26;} + + else if ( (LA52_0=='&') ) {s = 27;} + + else if ( (LA52_0=='<') ) {s = 28;} + + else if ( (LA52_0=='>') ) {s = 29;} + + else if ( (LA52_0=='=') ) {s = 30;} + + else if ( (LA52_0=='%') ) {s = 31;} + + else if ( (LA52_0=='`') ) {s = 32;} + + else if ( (LA52_0=='{') ) {s = 33;} + + else if ( (LA52_0=='}') ) {s = 34;} + + else if ( (LA52_0=='^') ) {s = 35;} + + else if ( (LA52_0=='~') ) {s = 36;} + + else if ( (LA52_0=='!') ) {s = 37;} + + else if ( (LA52_0=='.') ) {s = 38;} + + else if ( (LA52_0=='@') ) {s = 39;} + + else if ( (LA52_0=='o') ) {s = 40;} + + else if ( (LA52_0=='n') ) {s = 41;} + + else if ( (LA52_0=='0') ) {s = 42;} + + else if ( ((LA52_0>='1' && LA52_0<='9')) ) {s = 43;} + + else if ( (LA52_0=='u') ) {s = 44;} + + else if ( (LA52_0=='R') ) {s = 45;} + + else if ( (LA52_0=='U') ) {s = 46;} + + else if ( ((LA52_0>='A' && LA52_0<='Q')||(LA52_0>='S' && LA52_0<='T')||(LA52_0>='V' && LA52_0<='Z')||LA52_0=='_'||LA52_0=='h'||(LA52_0>='j' && LA52_0<='k')||LA52_0=='m'||LA52_0=='q'||LA52_0=='s'||LA52_0=='v'||LA52_0=='x'||LA52_0=='z') ) {s = 47;} + + else if ( (LA52_0=='\'') ) {s = 48;} + + else if ( (LA52_0=='\"') ) {s = 49;} + + else if ( (LA52_0=='\\') ) {s = 50;} + + else if ( (LA52_0=='\f') ) {s = 51;} + + else if ( (LA52_0=='\n'||LA52_0=='\r') ) {s = 52;} + + else if ( (LA52_0==' ') && (((startPos==0)||(startPos>0)))) {s = 53;} + + else if ( (LA52_0=='\t') && (((startPos==0)||(startPos>0)))) {s = 54;} + + else if ( (LA52_0=='#') ) {s = 55;} + + + input.seek(index52_0); + if ( s>=0 ) return s; + break; + case 46 : + int LA52_133 = input.LA(1); + + + int index52_133 = input.index(); + input.rewind(); + s = -1; + if ( ((startPos>0)) ) {s = 131;} + + else if ( (((startPos==0)||((startPos==0)&&(implicitLineJoiningLevel>0)))) ) {s = 134;} + + + input.seek(index52_133); + if ( s>=0 ) return s; + break; + case 47 : + int LA52_135 = input.LA(1); + + + int index52_135 = input.index(); + input.rewind(); + s = -1; + if ( ((startPos>0)) ) {s = 131;} + + else if ( (((startPos==0)||((startPos==0)&&(implicitLineJoiningLevel>0)))) ) {s = 134;} + + + input.seek(index52_135); + if ( s>=0 ) return s; + break; + case 48 : + int LA52_262 = input.LA(1); + + s = -1; + if ( ((LA52_262>='\u0000' && LA52_262<='\uFFFF')) ) {s = 226;} + + else s = 183; + + if ( s>=0 ) return s; + break; + case 49 : + int LA52_284 = input.LA(1); + + s = -1; + if ( ((LA52_284>='\u0000' && LA52_284<='\uFFFF')) ) {s = 225;} + + else s = 183; + + if ( s>=0 ) return s; + break; + case 50 : + int LA52_286 = input.LA(1); + + s = -1; + if ( (LA52_286=='\t'||LA52_286==' ') ) {s = 227;} + + else if ( (LA52_286=='#') ) {s = 228;} + + else if ( (LA52_286=='\f') ) {s = 229;} + + else if ( (LA52_286=='\r') ) {s = 230;} + + else if ( (LA52_286=='\'') ) {s = 183;} + + else if ( (LA52_286=='\\') ) {s = 126;} + + else if ( ((LA52_286>='\u0000' && LA52_286<='\b')||LA52_286=='\u000B'||(LA52_286>='\u000E' && LA52_286<='\u001F')||(LA52_286>='!' && LA52_286<='\"')||(LA52_286>='$' && LA52_286<='&')||(LA52_286>='(' && LA52_286<='[')||(LA52_286>=']' && LA52_286<='\uFFFF')) ) {s = 127;} + + else s = 226; + + if ( s>=0 ) return s; + break; + case 51 : + int LA52_232 = input.LA(1); + + s = -1; + if ( ((LA52_232>='\u0000' && LA52_232<='\uFFFF')) ) {s = 266;} + + else s = 225; + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 52, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/gensrc/org/python/antlr/PythonPartialParser.java b/gensrc/org/python/antlr/PythonPartialParser.java new file mode 100644 index 000000000..a9042a4d1 --- /dev/null +++ b/gensrc/org/python/antlr/PythonPartialParser.java @@ -0,0 +1,11350 @@ +// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g 2026-08-02 11:57:28 + +package org.python.antlr; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +/** Python 2.3.3 Grammar + * + * Terence Parr and Loring Craymer + * February 2004 + * + * Converted to ANTLR v3 November 2005 by Terence Parr. + * + * This grammar was derived automatically from the Python 2.3.3 + * parser grammar to get a syntactically correct ANTLR grammar + * for Python. Then Terence hand tweaked it to be semantically + * correct; i.e., removed lookahead issues etc... It is LL(1) + * except for the (sometimes optional) trailing commas and semi-colons. + * It needs two symbols of lookahead in this case. + * + * Starting with Loring's preliminary lexer for Python, I modified it + * to do my version of the whole nasty INDENT/DEDENT issue just so I + * could understand the problem better. This grammar requires + * PythonTokenStream.java to work. Also I used some rules from the + * semi-formal grammar on the web for Python (automatically + * translated to ANTLR format by an ANTLR grammar, naturally ). + * The lexical rules for python are particularly nasty and it took me + * a long time to get it 'right'; i.e., think about it in the proper + * way. Resist changing the lexer unless you've used ANTLR a lot. ;) + * + * I (Terence) tested this by running it on the jython-2.1/Lib + * directory of 40k lines of Python. + * + * REQUIRES ANTLR v3 + * + * Updated to Python 2.5 by Frank Wierzbicki. + * + */ +public class PythonPartialParser extends Parser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "INDENT", "DEDENT", "TRAILBACKSLASH", "NEWLINE", "LEADING_WS", "NAME", "DOT", "PRINT", "AND", "AS", "ASSERT", "BREAK", "CLASS", "CONTINUE", "DEF", "DELETE", "ELIF", "EXCEPT", "EXEC", "FINALLY", "FROM", "FOR", "GLOBAL", "IF", "IMPORT", "IN", "IS", "LAMBDA", "NOT", "OR", "ORELSE", "PASS", "RAISE", "RETURN", "TRY", "WHILE", "WITH", "YIELD", "AT", "LPAREN", "RPAREN", "COLON", "ASSIGN", "COMMA", "STAR", "DOUBLESTAR", "SEMI", "PLUSEQUAL", "MINUSEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", "DOUBLESTAREQUAL", "DOUBLESLASHEQUAL", "RIGHTSHIFT", "LESS", "GREATER", "EQUAL", "GREATEREQUAL", "LESSEQUAL", "ALT_NOTEQUAL", "NOTEQUAL", "VBAR", "CIRCUMFLEX", "AMPER", "LEFTSHIFT", "PLUS", "MINUS", "SLASH", "PERCENT", "DOUBLESLASH", "TILDE", "LBRACK", "RBRACK", "LCURLY", "RCURLY", "BACKQUOTE", "INT", "LONGINT", "FLOAT", "COMPLEX", "STRING", "DIGITS", "Exponent", "TRIAPOS", "TRIQUOTE", "ESC", "COMMENT", "CONTINUED_LINE", "WS", "TRISTRINGPART", "STRINGPART" + }; + public static final int PRINT=11; + public static final int TRISTRINGPART=99; + public static final int VBAREQUAL=57; + public static final int MINUS=76; + public static final int TRAILBACKSLASH=6; + public static final int SLASHEQUAL=54; + public static final int BREAK=15; + public static final int IF=27; + public static final int LESSEQUAL=68; + public static final int ELIF=20; + public static final int IN=29; + public static final int DOT=10; + public static final int LPAREN=43; + public static final int IS=30; + public static final int AS=13; + public static final int AT=42; + public static final int PASS=35; + public static final int LBRACK=81; + public static final int LEADING_WS=8; + public static final int LONGINT=87; + public static final int SEMI=50; + public static final int ASSIGN=46; + public static final int CIRCUMFLEXEQUAL=58; + public static final int DOUBLESTAREQUAL=61; + public static final int COMMENT=96; + public static final int INDENT=4; + public static final int IMPORT=28; + public static final int DELETE=19; + public static final int ESC=95; + public static final int ALT_NOTEQUAL=69; + public static final int RCURLY=84; + public static final int COMMA=47; + public static final int TRIQUOTE=94; + public static final int YIELD=41; + public static final int STAREQUAL=53; + public static final int GREATER=65; + public static final int LCURLY=83; + public static final int DOUBLESLASHEQUAL=62; + public static final int RAISE=36; + public static final int CONTINUE=17; + public static final int LEFTSHIFTEQUAL=59; + public static final int STAR=48; + public static final int PERCENT=78; + public static final int STRING=90; + public static final int BACKQUOTE=85; + public static final int CLASS=16; + public static final int FROM=24; + public static final int FINALLY=23; + public static final int RIGHTSHIFTEQUAL=60; + public static final int TRY=38; + public static final int NEWLINE=7; + public static final int FOR=25; + public static final int RPAREN=44; + public static final int EXCEPT=21; + public static final int RIGHTSHIFT=63; + public static final int NAME=9; + public static final int LAMBDA=31; + public static final int NOTEQUAL=70; + public static final int EXEC=22; + public static final int NOT=32; + public static final int RBRACK=82; + public static final int AND=12; + public static final int STRINGPART=100; + public static final int PERCENTEQUAL=55; + public static final int LESS=64; + public static final int LEFTSHIFT=74; + public static final int PLUS=75; + public static final int DOUBLESTAR=49; + public static final int FLOAT=88; + public static final int TRIAPOS=93; + public static final int Exponent=92; + public static final int DIGITS=91; + public static final int INT=86; + public static final int DOUBLESLASH=79; + public static final int RETURN=37; + public static final int GLOBAL=26; + public static final int CONTINUED_LINE=97; + public static final int WS=98; + public static final int EOF=-1; + public static final int CIRCUMFLEX=72; + public static final int COMPLEX=89; + public static final int OR=33; + public static final int DEF=18; + public static final int ASSERT=14; + public static final int AMPEREQUAL=56; + public static final int EQUAL=66; + public static final int SLASH=77; + public static final int AMPER=73; + public static final int COLON=45; + public static final int ORELSE=34; + public static final int WITH=40; + public static final int VBAR=71; + public static final int PLUSEQUAL=51; + public static final int MINUSEQUAL=52; + public static final int GREATEREQUAL=67; + public static final int WHILE=39; + public static final int TILDE=80; + public static final int DEDENT=5; + + // delegates + // delegators + + + public PythonPartialParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public PythonPartialParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return PythonPartialParser.tokenNames; } + public String getGrammarFileName() { return "/Users/orion.moore/apps/code/jython/grammar/PythonPartial.g"; } + + + private ErrorHandler errorHandler = new FailFastHandler(); + + protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) + throws RecognitionException { + + Object o = errorHandler.recoverFromMismatchedToken(this, input, ttype, follow); + if (o != null) { + return o; + } + return super.recoverFromMismatchedToken(input, ttype, follow); + } + + + + + // $ANTLR start "single_input" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:166:1: single_input : ( NEWLINE | simple_stmt | compound_stmt ( NEWLINE )? EOF ); + public final void single_input() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:168:5: ( NEWLINE | simple_stmt | compound_stmt ( NEWLINE )? EOF ) + int alt2=3; + switch ( input.LA(1) ) { + case NEWLINE: + { + alt2=1; + } + break; + case TRAILBACKSLASH: + case NAME: + case PRINT: + case ASSERT: + case BREAK: + case CONTINUE: + case DELETE: + case EXEC: + case FROM: + case GLOBAL: + case IMPORT: + case LAMBDA: + case NOT: + case PASS: + case RAISE: + case RETURN: + case YIELD: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case LBRACK: + case LCURLY: + case BACKQUOTE: + case INT: + case LONGINT: + case FLOAT: + case COMPLEX: + case STRING: + case TRISTRINGPART: + case STRINGPART: + { + alt2=2; + } + break; + case CLASS: + case DEF: + case FOR: + case IF: + case TRY: + case WHILE: + case WITH: + case AT: + { + alt2=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + + switch (alt2) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:168:7: NEWLINE + { + match(input,NEWLINE,FOLLOW_NEWLINE_in_single_input72); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:169:7: simple_stmt + { + pushFollow(FOLLOW_simple_stmt_in_single_input80); + simple_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:170:7: compound_stmt ( NEWLINE )? EOF + { + pushFollow(FOLLOW_compound_stmt_in_single_input88); + compound_stmt(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:170:21: ( NEWLINE )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==NEWLINE) ) { + alt1=1; + } + switch (alt1) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:170:21: NEWLINE + { + match(input,NEWLINE,FOLLOW_NEWLINE_in_single_input90); if (state.failed) return ; + + } + break; + + } + + match(input,EOF,FOLLOW_EOF_in_single_input93); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "single_input" + + + // $ANTLR start "eval_input" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:174:1: eval_input : ( LEADING_WS )? ( NEWLINE )* ( testlist )? ( NEWLINE )* EOF ; + public final void eval_input() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:5: ( ( LEADING_WS )? ( NEWLINE )* ( testlist )? ( NEWLINE )* EOF ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:7: ( LEADING_WS )? ( NEWLINE )* ( testlist )? ( NEWLINE )* EOF + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:7: ( LEADING_WS )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==LEADING_WS) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:7: LEADING_WS + { + match(input,LEADING_WS,FOLLOW_LEADING_WS_in_eval_input111); if (state.failed) return ; + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:19: ( NEWLINE )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==NEWLINE) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:20: NEWLINE + { + match(input,NEWLINE,FOLLOW_NEWLINE_in_eval_input115); if (state.failed) return ; + + } + break; + + default : + break loop4; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:30: ( testlist )? + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==TRAILBACKSLASH||LA5_0==NAME||(LA5_0>=LAMBDA && LA5_0<=NOT)||LA5_0==LPAREN||(LA5_0>=PLUS && LA5_0<=MINUS)||(LA5_0>=TILDE && LA5_0<=LBRACK)||LA5_0==LCURLY||(LA5_0>=BACKQUOTE && LA5_0<=STRING)||(LA5_0>=TRISTRINGPART && LA5_0<=STRINGPART)) ) { + alt5=1; + } + switch (alt5) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:30: testlist + { + pushFollow(FOLLOW_testlist_in_eval_input119); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:40: ( NEWLINE )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==NEWLINE) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:175:41: NEWLINE + { + match(input,NEWLINE,FOLLOW_NEWLINE_in_eval_input123); if (state.failed) return ; + + } + break; + + default : + break loop6; + } + } while (true); + + match(input,EOF,FOLLOW_EOF_in_eval_input127); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "eval_input" + + + // $ANTLR start "dotted_attr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:179:1: dotted_attr : NAME ( ( DOT NAME )+ | ) ; + public final void dotted_attr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:180:5: ( NAME ( ( DOT NAME )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:180:7: NAME ( ( DOT NAME )+ | ) + { + match(input,NAME,FOLLOW_NAME_in_dotted_attr145); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:181:7: ( ( DOT NAME )+ | ) + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==DOT) ) { + alt8=1; + } + else if ( (LA8_0==NEWLINE||LA8_0==LPAREN) ) { + alt8=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + + throw nvae; + } + switch (alt8) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:181:9: ( DOT NAME )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:181:9: ( DOT NAME )+ + int cnt7=0; + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==DOT) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:181:10: DOT NAME + { + match(input,DOT,FOLLOW_DOT_in_dotted_attr156); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_dotted_attr158); if (state.failed) return ; + + } + break; + + default : + if ( cnt7 >= 1 ) break loop7; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(7, input); + throw eee; + } + cnt7++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:183:7: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "dotted_attr" + + + // $ANTLR start "attr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:201:1: attr : ( NAME | AND | AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | NOT | OR | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD ); + public final void attr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:202:5: ( NAME | AND | AS | ASSERT | BREAK | CLASS | CONTINUE | DEF | DELETE | ELIF | EXCEPT | EXEC | FINALLY | FROM | FOR | GLOBAL | IF | IMPORT | IN | IS | LAMBDA | NOT | OR | ORELSE | PASS | PRINT | RAISE | RETURN | TRY | WHILE | WITH | YIELD ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)==NAME||(input.LA(1)>=PRINT && input.LA(1)<=YIELD) ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "attr" + + + // $ANTLR start "decorator" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:237:1: decorator : AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE ; + public final void decorator() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:238:5: ( AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:238:7: AT dotted_attr ( LPAREN ( arglist | ) RPAREN | ) NEWLINE + { + match(input,AT,FOLLOW_AT_in_decorator464); if (state.failed) return ; + pushFollow(FOLLOW_dotted_attr_in_decorator466); + dotted_attr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:239:5: ( LPAREN ( arglist | ) RPAREN | ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==LPAREN) ) { + alt10=1; + } + else if ( (LA10_0==NEWLINE) ) { + alt10=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:239:7: LPAREN ( arglist | ) RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_decorator474); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:240:7: ( arglist | ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==TRAILBACKSLASH||LA9_0==NAME||(LA9_0>=LAMBDA && LA9_0<=NOT)||LA9_0==LPAREN||(LA9_0>=STAR && LA9_0<=DOUBLESTAR)||(LA9_0>=PLUS && LA9_0<=MINUS)||(LA9_0>=TILDE && LA9_0<=LBRACK)||LA9_0==LCURLY||(LA9_0>=BACKQUOTE && LA9_0<=STRING)||(LA9_0>=TRISTRINGPART && LA9_0<=STRINGPART)) ) { + alt9=1; + } + else if ( (LA9_0==RPAREN) ) { + alt9=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:240:9: arglist + { + pushFollow(FOLLOW_arglist_in_decorator484); + arglist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:242:7: + { + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_decorator508); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:245:5: + { + } + break; + + } + + match(input,NEWLINE,FOLLOW_NEWLINE_in_decorator522); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "decorator" + + + // $ANTLR start "decorators" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:249:1: decorators : ( decorator )+ ; + public final void decorators() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:250:5: ( ( decorator )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:250:7: ( decorator )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:250:7: ( decorator )+ + int cnt11=0; + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==AT) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:250:7: decorator + { + pushFollow(FOLLOW_decorator_in_decorators540); + decorator(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt11 >= 1 ) break loop11; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(11, input); + throw eee; + } + cnt11++; + } while (true); + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "decorators" + + + // $ANTLR start "funcdef" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:254:1: funcdef : ( decorators )? DEF NAME parameters COLON suite ; + public final void funcdef() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:255:5: ( ( decorators )? DEF NAME parameters COLON suite ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:255:7: ( decorators )? DEF NAME parameters COLON suite + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:255:7: ( decorators )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==AT) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:255:7: decorators + { + pushFollow(FOLLOW_decorators_in_funcdef559); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,DEF,FOLLOW_DEF_in_funcdef562); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_funcdef564); if (state.failed) return ; + pushFollow(FOLLOW_parameters_in_funcdef566); + parameters(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_funcdef568); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_funcdef570); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "funcdef" + + + // $ANTLR start "parameters" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:259:1: parameters : LPAREN ( varargslist | ) RPAREN ; + public final void parameters() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:260:5: ( LPAREN ( varargslist | ) RPAREN ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:260:7: LPAREN ( varargslist | ) RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_parameters588); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:261:7: ( varargslist | ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==NAME||LA13_0==LPAREN||(LA13_0>=STAR && LA13_0<=DOUBLESTAR)) ) { + alt13=1; + } + else if ( (LA13_0==RPAREN) ) { + alt13=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:261:8: varargslist + { + pushFollow(FOLLOW_varargslist_in_parameters597); + varargslist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:263:7: + { + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_parameters621); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "parameters" + + + // $ANTLR start "defparameter" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:268:1: defparameter : fpdef ( ASSIGN test )? ; + public final void defparameter() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:269:5: ( fpdef ( ASSIGN test )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:269:7: fpdef ( ASSIGN test )? + { + pushFollow(FOLLOW_fpdef_in_defparameter639); + fpdef(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:269:13: ( ASSIGN test )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==ASSIGN) ) { + alt14=1; + } + switch (alt14) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:269:14: ASSIGN test + { + match(input,ASSIGN,FOLLOW_ASSIGN_in_defparameter642); if (state.failed) return ; + pushFollow(FOLLOW_test_in_defparameter644); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "defparameter" + + + // $ANTLR start "varargslist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:275:1: varargslist : ( defparameter ( options {greedy=true; } : COMMA defparameter )* ( COMMA ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? )? | STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME ); + public final void varargslist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:276:5: ( defparameter ( options {greedy=true; } : COMMA defparameter )* ( COMMA ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? )? | STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME ) + int alt20=3; + switch ( input.LA(1) ) { + case NAME: + case LPAREN: + { + alt20=1; + } + break; + case STAR: + { + alt20=2; + } + break; + case DOUBLESTAR: + { + alt20=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 20, 0, input); + + throw nvae; + } + + switch (alt20) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:276:7: defparameter ( options {greedy=true; } : COMMA defparameter )* ( COMMA ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? )? + { + pushFollow(FOLLOW_defparameter_in_varargslist666); + defparameter(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:276:20: ( options {greedy=true; } : COMMA defparameter )* + loop15: + do { + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==COMMA) ) { + int LA15_1 = input.LA(2); + + if ( (LA15_1==NAME||LA15_1==LPAREN) ) { + alt15=1; + } + + + } + + + switch (alt15) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:276:44: COMMA defparameter + { + match(input,COMMA,FOLLOW_COMMA_in_varargslist676); if (state.failed) return ; + pushFollow(FOLLOW_defparameter_in_varargslist678); + defparameter(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop15; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:277:7: ( COMMA ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==COMMA) ) { + alt18=1; + } + switch (alt18) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:277:8: COMMA ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? + { + match(input,COMMA,FOLLOW_COMMA_in_varargslist689); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:278:11: ( STAR NAME ( COMMA DOUBLESTAR NAME )? | DOUBLESTAR NAME )? + int alt17=3; + int LA17_0 = input.LA(1); + + if ( (LA17_0==STAR) ) { + alt17=1; + } + else if ( (LA17_0==DOUBLESTAR) ) { + alt17=2; + } + switch (alt17) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:278:12: STAR NAME ( COMMA DOUBLESTAR NAME )? + { + match(input,STAR,FOLLOW_STAR_in_varargslist702); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist704); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:278:22: ( COMMA DOUBLESTAR NAME )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==COMMA) ) { + alt16=1; + } + switch (alt16) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:278:23: COMMA DOUBLESTAR NAME + { + match(input,COMMA,FOLLOW_COMMA_in_varargslist707); if (state.failed) return ; + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist709); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist711); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:279:13: DOUBLESTAR NAME + { + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist727); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist729); if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:282:7: STAR NAME ( COMMA DOUBLESTAR NAME )? + { + match(input,STAR,FOLLOW_STAR_in_varargslist759); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist761); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:282:17: ( COMMA DOUBLESTAR NAME )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==COMMA) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:282:18: COMMA DOUBLESTAR NAME + { + match(input,COMMA,FOLLOW_COMMA_in_varargslist764); if (state.failed) return ; + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist766); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist768); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:283:7: DOUBLESTAR NAME + { + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_varargslist778); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_varargslist780); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "varargslist" + + + // $ANTLR start "fpdef" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:287:1: fpdef : ( NAME | ( LPAREN fpdef COMMA )=> LPAREN fplist RPAREN | LPAREN fplist RPAREN ); + public final void fpdef() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:288:5: ( NAME | ( LPAREN fpdef COMMA )=> LPAREN fplist RPAREN | LPAREN fplist RPAREN ) + int alt21=3; + int LA21_0 = input.LA(1); + + if ( (LA21_0==NAME) ) { + alt21=1; + } + else if ( (LA21_0==LPAREN) ) { + int LA21_2 = input.LA(2); + + if ( (synpred1_PythonPartial()) ) { + alt21=2; + } + else if ( (true) ) { + alt21=3; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 2, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 0, input); + + throw nvae; + } + switch (alt21) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:288:7: NAME + { + match(input,NAME,FOLLOW_NAME_in_fpdef798); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:289:7: ( LPAREN fpdef COMMA )=> LPAREN fplist RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_fpdef816); if (state.failed) return ; + pushFollow(FOLLOW_fplist_in_fpdef818); + fplist(); + + state._fsp--; + if (state.failed) return ; + match(input,RPAREN,FOLLOW_RPAREN_in_fpdef820); if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:290:7: LPAREN fplist RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_fpdef828); if (state.failed) return ; + pushFollow(FOLLOW_fplist_in_fpdef830); + fplist(); + + state._fsp--; + if (state.failed) return ; + match(input,RPAREN,FOLLOW_RPAREN_in_fpdef832); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "fpdef" + + + // $ANTLR start "fplist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:294:1: fplist : fpdef ( options {greedy=true; } : COMMA fpdef )* ( COMMA )? ; + public final void fplist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:295:5: ( fpdef ( options {greedy=true; } : COMMA fpdef )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:295:7: fpdef ( options {greedy=true; } : COMMA fpdef )* ( COMMA )? + { + pushFollow(FOLLOW_fpdef_in_fplist850); + fpdef(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:296:7: ( options {greedy=true; } : COMMA fpdef )* + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==COMMA) ) { + int LA22_1 = input.LA(2); + + if ( (LA22_1==NAME||LA22_1==LPAREN) ) { + alt22=1; + } + + + } + + + switch (alt22) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:296:31: COMMA fpdef + { + match(input,COMMA,FOLLOW_COMMA_in_fplist866); if (state.failed) return ; + pushFollow(FOLLOW_fpdef_in_fplist868); + fpdef(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop22; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:296:45: ( COMMA )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0==COMMA) ) { + alt23=1; + } + switch (alt23) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:296:46: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_fplist873); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "fplist" + + + // $ANTLR start "stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:300:1: stmt : ( simple_stmt | compound_stmt ); + public final void stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:301:5: ( simple_stmt | compound_stmt ) + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==TRAILBACKSLASH||LA24_0==NAME||LA24_0==PRINT||(LA24_0>=ASSERT && LA24_0<=BREAK)||LA24_0==CONTINUE||LA24_0==DELETE||LA24_0==EXEC||LA24_0==FROM||LA24_0==GLOBAL||LA24_0==IMPORT||(LA24_0>=LAMBDA && LA24_0<=NOT)||(LA24_0>=PASS && LA24_0<=RETURN)||LA24_0==YIELD||LA24_0==LPAREN||(LA24_0>=PLUS && LA24_0<=MINUS)||(LA24_0>=TILDE && LA24_0<=LBRACK)||LA24_0==LCURLY||(LA24_0>=BACKQUOTE && LA24_0<=STRING)||(LA24_0>=TRISTRINGPART && LA24_0<=STRINGPART)) ) { + alt24=1; + } + else if ( (LA24_0==CLASS||LA24_0==DEF||LA24_0==FOR||LA24_0==IF||(LA24_0>=TRY && LA24_0<=WITH)||LA24_0==AT) ) { + alt24=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + + throw nvae; + } + switch (alt24) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:301:7: simple_stmt + { + pushFollow(FOLLOW_simple_stmt_in_stmt893); + simple_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:302:7: compound_stmt + { + pushFollow(FOLLOW_compound_stmt_in_stmt901); + compound_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "stmt" + + + // $ANTLR start "simple_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:306:1: simple_stmt : small_stmt ( options {greedy=true; } : SEMI small_stmt )* ( SEMI )? ( NEWLINE | EOF ) ; + public final void simple_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:5: ( small_stmt ( options {greedy=true; } : SEMI small_stmt )* ( SEMI )? ( NEWLINE | EOF ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:7: small_stmt ( options {greedy=true; } : SEMI small_stmt )* ( SEMI )? ( NEWLINE | EOF ) + { + pushFollow(FOLLOW_small_stmt_in_simple_stmt919); + small_stmt(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:18: ( options {greedy=true; } : SEMI small_stmt )* + loop25: + do { + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==SEMI) ) { + int LA25_1 = input.LA(2); + + if ( (LA25_1==TRAILBACKSLASH||LA25_1==NAME||LA25_1==PRINT||(LA25_1>=ASSERT && LA25_1<=BREAK)||LA25_1==CONTINUE||LA25_1==DELETE||LA25_1==EXEC||LA25_1==FROM||LA25_1==GLOBAL||LA25_1==IMPORT||(LA25_1>=LAMBDA && LA25_1<=NOT)||(LA25_1>=PASS && LA25_1<=RETURN)||LA25_1==YIELD||LA25_1==LPAREN||(LA25_1>=PLUS && LA25_1<=MINUS)||(LA25_1>=TILDE && LA25_1<=LBRACK)||LA25_1==LCURLY||(LA25_1>=BACKQUOTE && LA25_1<=STRING)||(LA25_1>=TRISTRINGPART && LA25_1<=STRINGPART)) ) { + alt25=1; + } + + + } + + + switch (alt25) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:42: SEMI small_stmt + { + match(input,SEMI,FOLLOW_SEMI_in_simple_stmt929); if (state.failed) return ; + pushFollow(FOLLOW_small_stmt_in_simple_stmt931); + small_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop25; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:60: ( SEMI )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==SEMI) ) { + alt26=1; + } + switch (alt26) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:307:61: SEMI + { + match(input,SEMI,FOLLOW_SEMI_in_simple_stmt936); if (state.failed) return ; + + } + break; + + } + + if ( input.LA(1)==EOF||input.LA(1)==NEWLINE ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "simple_stmt" + + + // $ANTLR start "small_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:312:1: small_stmt : ( expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt ); + public final void small_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:312:12: ( expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt ) + int alt27=9; + alt27 = dfa27.predict(input); + switch (alt27) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:312:14: expr_stmt + { + pushFollow(FOLLOW_expr_stmt_in_small_stmt959); + expr_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:313:14: print_stmt + { + pushFollow(FOLLOW_print_stmt_in_small_stmt974); + print_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:314:14: del_stmt + { + pushFollow(FOLLOW_del_stmt_in_small_stmt989); + del_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:315:14: pass_stmt + { + pushFollow(FOLLOW_pass_stmt_in_small_stmt1004); + pass_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:316:14: flow_stmt + { + pushFollow(FOLLOW_flow_stmt_in_small_stmt1019); + flow_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:317:14: import_stmt + { + pushFollow(FOLLOW_import_stmt_in_small_stmt1034); + import_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:318:14: global_stmt + { + pushFollow(FOLLOW_global_stmt_in_small_stmt1049); + global_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:319:14: exec_stmt + { + pushFollow(FOLLOW_exec_stmt_in_small_stmt1064); + exec_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:320:14: assert_stmt + { + pushFollow(FOLLOW_assert_stmt_in_small_stmt1079); + assert_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "small_stmt" + + + // $ANTLR start "expr_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:325:1: expr_stmt : ( ( testlist augassign )=> testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) | ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) | testlist ) ; + public final void expr_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:5: ( ( ( testlist augassign )=> testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) | ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) | testlist ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:7: ( ( testlist augassign )=> testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) | ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) | testlist ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:7: ( ( testlist augassign )=> testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) | ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) | testlist ) + int alt32=3; + alt32 = dfa32.predict(input); + switch (alt32) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:8: ( testlist augassign )=> testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) + { + pushFollow(FOLLOW_testlist_in_expr_stmt1114); + testlist(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:327:9: ( ( augassign yield_expr ) | ( augassign testlist ) ) + int alt28=2; + int LA28_0 = input.LA(1); + + if ( ((LA28_0>=PLUSEQUAL && LA28_0<=DOUBLESLASHEQUAL)) ) { + int LA28_1 = input.LA(2); + + if ( (LA28_1==YIELD) ) { + alt28=1; + } + else if ( (LA28_1==TRAILBACKSLASH||LA28_1==NAME||(LA28_1>=LAMBDA && LA28_1<=NOT)||LA28_1==LPAREN||(LA28_1>=PLUS && LA28_1<=MINUS)||(LA28_1>=TILDE && LA28_1<=LBRACK)||LA28_1==LCURLY||(LA28_1>=BACKQUOTE && LA28_1<=STRING)||(LA28_1>=TRISTRINGPART && LA28_1<=STRINGPART)) ) { + alt28=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 0, input); + + throw nvae; + } + switch (alt28) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:327:11: ( augassign yield_expr ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:327:11: ( augassign yield_expr ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:327:12: augassign yield_expr + { + pushFollow(FOLLOW_augassign_in_expr_stmt1127); + augassign(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_yield_expr_in_expr_stmt1129); + yield_expr(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:329:11: ( augassign testlist ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:329:11: ( augassign testlist ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:329:12: augassign testlist + { + pushFollow(FOLLOW_augassign_in_expr_stmt1154); + augassign(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_testlist_in_expr_stmt1156); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:332:7: ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) + { + pushFollow(FOLLOW_testlist_in_expr_stmt1194); + testlist(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:333:9: ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) + int alt31=3; + int LA31_0 = input.LA(1); + + if ( (LA31_0==EOF||LA31_0==NEWLINE||LA31_0==SEMI) ) { + alt31=1; + } + else if ( (LA31_0==ASSIGN) ) { + int LA31_2 = input.LA(2); + + if ( (LA31_2==YIELD) ) { + alt31=3; + } + else if ( (LA31_2==TRAILBACKSLASH||LA31_2==NAME||(LA31_2>=LAMBDA && LA31_2<=NOT)||LA31_2==LPAREN||(LA31_2>=PLUS && LA31_2<=MINUS)||(LA31_2>=TILDE && LA31_2<=LBRACK)||LA31_2==LCURLY||(LA31_2>=BACKQUOTE && LA31_2<=STRING)||(LA31_2>=TRISTRINGPART && LA31_2<=STRINGPART)) ) { + alt31=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 31, 2, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 31, 0, input); + + throw nvae; + } + switch (alt31) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:9: + { + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:11: ( ( ASSIGN testlist )+ ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:11: ( ( ASSIGN testlist )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:12: ( ASSIGN testlist )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:12: ( ASSIGN testlist )+ + int cnt29=0; + loop29: + do { + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==ASSIGN) ) { + alt29=1; + } + + + switch (alt29) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:334:13: ASSIGN testlist + { + match(input,ASSIGN,FOLLOW_ASSIGN_in_expr_stmt1218); if (state.failed) return ; + pushFollow(FOLLOW_testlist_in_expr_stmt1220); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt29 >= 1 ) break loop29; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(29, input); + throw eee; + } + cnt29++; + } while (true); + + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:336:11: ( ( ASSIGN yield_expr )+ ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:336:11: ( ( ASSIGN yield_expr )+ ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:336:12: ( ASSIGN yield_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:336:12: ( ASSIGN yield_expr )+ + int cnt30=0; + loop30: + do { + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==ASSIGN) ) { + alt30=1; + } + + + switch (alt30) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:336:13: ASSIGN yield_expr + { + match(input,ASSIGN,FOLLOW_ASSIGN_in_expr_stmt1248); if (state.failed) return ; + pushFollow(FOLLOW_yield_expr_in_expr_stmt1250); + yield_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt30 >= 1 ) break loop30; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(30, input); + throw eee; + } + cnt30++; + } while (true); + + + } + + + } + break; + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:339:7: testlist + { + pushFollow(FOLLOW_testlist_in_expr_stmt1282); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "expr_stmt" + + + // $ANTLR start "augassign" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:345:1: augassign : ( PLUSEQUAL | MINUSEQUAL | STAREQUAL | SLASHEQUAL | PERCENTEQUAL | AMPEREQUAL | VBAREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL ); + public final void augassign() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:346:5: ( PLUSEQUAL | MINUSEQUAL | STAREQUAL | SLASHEQUAL | PERCENTEQUAL | AMPEREQUAL | VBAREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( (input.LA(1)>=PLUSEQUAL && input.LA(1)<=DOUBLESLASHEQUAL) ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "augassign" + + + // $ANTLR start "print_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:362:1: print_stmt : PRINT ( printlist | RIGHTSHIFT printlist | ) ; + public final void print_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:363:5: ( PRINT ( printlist | RIGHTSHIFT printlist | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:363:7: PRINT ( printlist | RIGHTSHIFT printlist | ) + { + match(input,PRINT,FOLLOW_PRINT_in_print_stmt1414); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:364:7: ( printlist | RIGHTSHIFT printlist | ) + int alt33=3; + switch ( input.LA(1) ) { + case TRAILBACKSLASH: + case NAME: + case LAMBDA: + case NOT: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case LBRACK: + case LCURLY: + case BACKQUOTE: + case INT: + case LONGINT: + case FLOAT: + case COMPLEX: + case STRING: + case TRISTRINGPART: + case STRINGPART: + { + alt33=1; + } + break; + case RIGHTSHIFT: + { + alt33=2; + } + break; + case EOF: + case NEWLINE: + case SEMI: + { + alt33=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 33, 0, input); + + throw nvae; + } + + switch (alt33) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:364:8: printlist + { + pushFollow(FOLLOW_printlist_in_print_stmt1423); + printlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:365:9: RIGHTSHIFT printlist + { + match(input,RIGHTSHIFT,FOLLOW_RIGHTSHIFT_in_print_stmt1433); if (state.failed) return ; + pushFollow(FOLLOW_printlist_in_print_stmt1435); + printlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:367:7: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "print_stmt" + + + // $ANTLR start "printlist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:371:1: printlist : ( ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? | test ); + public final void printlist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:372:5: ( ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? | test ) + int alt36=2; + alt36 = dfa36.predict(input); + switch (alt36) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:372:7: ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? + { + pushFollow(FOLLOW_test_in_printlist1486); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:373:13: ( options {k=2; } : COMMA test )* + loop34: + do { + int alt34=2; + alt34 = dfa34.predict(input); + switch (alt34) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:373:30: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_printlist1497); if (state.failed) return ; + pushFollow(FOLLOW_test_in_printlist1499); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop34; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:374:10: ( COMMA )? + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==COMMA) ) { + alt35=1; + } + switch (alt35) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:374:11: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_printlist1513); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:375:7: test + { + pushFollow(FOLLOW_test_in_printlist1523); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "printlist" + + + // $ANTLR start "del_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:379:1: del_stmt : DELETE exprlist ; + public final void del_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:380:5: ( DELETE exprlist ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:380:7: DELETE exprlist + { + match(input,DELETE,FOLLOW_DELETE_in_del_stmt1541); if (state.failed) return ; + pushFollow(FOLLOW_exprlist_in_del_stmt1543); + exprlist(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "del_stmt" + + + // $ANTLR start "pass_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:384:1: pass_stmt : PASS ; + public final void pass_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:385:5: ( PASS ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:385:7: PASS + { + match(input,PASS,FOLLOW_PASS_in_pass_stmt1561); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "pass_stmt" + + + // $ANTLR start "flow_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:389:1: flow_stmt : ( break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt ); + public final void flow_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:390:5: ( break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt ) + int alt37=5; + switch ( input.LA(1) ) { + case BREAK: + { + alt37=1; + } + break; + case CONTINUE: + { + alt37=2; + } + break; + case RETURN: + { + alt37=3; + } + break; + case RAISE: + { + alt37=4; + } + break; + case YIELD: + { + alt37=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); + + throw nvae; + } + + switch (alt37) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:390:7: break_stmt + { + pushFollow(FOLLOW_break_stmt_in_flow_stmt1579); + break_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:391:7: continue_stmt + { + pushFollow(FOLLOW_continue_stmt_in_flow_stmt1587); + continue_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:392:7: return_stmt + { + pushFollow(FOLLOW_return_stmt_in_flow_stmt1595); + return_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:393:7: raise_stmt + { + pushFollow(FOLLOW_raise_stmt_in_flow_stmt1603); + raise_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:394:7: yield_stmt + { + pushFollow(FOLLOW_yield_stmt_in_flow_stmt1611); + yield_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "flow_stmt" + + + // $ANTLR start "break_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:398:1: break_stmt : BREAK ; + public final void break_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:399:5: ( BREAK ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:399:7: BREAK + { + match(input,BREAK,FOLLOW_BREAK_in_break_stmt1629); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "break_stmt" + + + // $ANTLR start "continue_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:403:1: continue_stmt : CONTINUE ; + public final void continue_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:404:5: ( CONTINUE ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:404:7: CONTINUE + { + match(input,CONTINUE,FOLLOW_CONTINUE_in_continue_stmt1647); if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "continue_stmt" + + + // $ANTLR start "return_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:408:1: return_stmt : RETURN ( testlist | ) ; + public final void return_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:409:5: ( RETURN ( testlist | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:409:7: RETURN ( testlist | ) + { + match(input,RETURN,FOLLOW_RETURN_in_return_stmt1665); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:410:7: ( testlist | ) + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==TRAILBACKSLASH||LA38_0==NAME||(LA38_0>=LAMBDA && LA38_0<=NOT)||LA38_0==LPAREN||(LA38_0>=PLUS && LA38_0<=MINUS)||(LA38_0>=TILDE && LA38_0<=LBRACK)||LA38_0==LCURLY||(LA38_0>=BACKQUOTE && LA38_0<=STRING)||(LA38_0>=TRISTRINGPART && LA38_0<=STRINGPART)) ) { + alt38=1; + } + else if ( (LA38_0==EOF||LA38_0==NEWLINE||LA38_0==SEMI) ) { + alt38=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 38, 0, input); + + throw nvae; + } + switch (alt38) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:410:8: testlist + { + pushFollow(FOLLOW_testlist_in_return_stmt1674); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:412:7: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "return_stmt" + + + // $ANTLR start "yield_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:416:1: yield_stmt : yield_expr ; + public final void yield_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:417:5: ( yield_expr ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:417:7: yield_expr + { + pushFollow(FOLLOW_yield_expr_in_yield_stmt1708); + yield_expr(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "yield_stmt" + + + // $ANTLR start "raise_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:421:1: raise_stmt : RAISE ( test ( COMMA test ( COMMA test )? )? )? ; + public final void raise_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:5: ( RAISE ( test ( COMMA test ( COMMA test )? )? )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:7: RAISE ( test ( COMMA test ( COMMA test )? )? )? + { + match(input,RAISE,FOLLOW_RAISE_in_raise_stmt1726); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:13: ( test ( COMMA test ( COMMA test )? )? )? + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==TRAILBACKSLASH||LA41_0==NAME||(LA41_0>=LAMBDA && LA41_0<=NOT)||LA41_0==LPAREN||(LA41_0>=PLUS && LA41_0<=MINUS)||(LA41_0>=TILDE && LA41_0<=LBRACK)||LA41_0==LCURLY||(LA41_0>=BACKQUOTE && LA41_0<=STRING)||(LA41_0>=TRISTRINGPART && LA41_0<=STRINGPART)) ) { + alt41=1; + } + switch (alt41) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:14: test ( COMMA test ( COMMA test )? )? + { + pushFollow(FOLLOW_test_in_raise_stmt1729); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:19: ( COMMA test ( COMMA test )? )? + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==COMMA) ) { + alt40=1; + } + switch (alt40) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:422:20: COMMA test ( COMMA test )? + { + match(input,COMMA,FOLLOW_COMMA_in_raise_stmt1732); if (state.failed) return ; + pushFollow(FOLLOW_test_in_raise_stmt1734); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:423:9: ( COMMA test )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==COMMA) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:423:10: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_raise_stmt1745); if (state.failed) return ; + pushFollow(FOLLOW_test_in_raise_stmt1747); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "raise_stmt" + + + // $ANTLR start "import_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:427:1: import_stmt : ( import_name | import_from ); + public final void import_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:428:5: ( import_name | import_from ) + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==IMPORT) ) { + alt42=1; + } + else if ( (LA42_0==FROM) ) { + alt42=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 42, 0, input); + + throw nvae; + } + switch (alt42) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:428:7: import_name + { + pushFollow(FOLLOW_import_name_in_import_stmt1771); + import_name(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:429:7: import_from + { + pushFollow(FOLLOW_import_from_in_import_stmt1779); + import_from(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "import_stmt" + + + // $ANTLR start "import_name" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:433:1: import_name : IMPORT dotted_as_names ; + public final void import_name() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:434:5: ( IMPORT dotted_as_names ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:434:7: IMPORT dotted_as_names + { + match(input,IMPORT,FOLLOW_IMPORT_in_import_name1797); if (state.failed) return ; + pushFollow(FOLLOW_dotted_as_names_in_import_name1799); + dotted_as_names(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "import_name" + + + // $ANTLR start "import_from" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:439:1: import_from : FROM ( ( DOT )* dotted_name | ( DOT )+ ) IMPORT ( STAR | import_as_names | LPAREN import_as_names ( COMMA )? RPAREN ) ; + public final void import_from() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:5: ( FROM ( ( DOT )* dotted_name | ( DOT )+ ) IMPORT ( STAR | import_as_names | LPAREN import_as_names ( COMMA )? RPAREN ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:7: FROM ( ( DOT )* dotted_name | ( DOT )+ ) IMPORT ( STAR | import_as_names | LPAREN import_as_names ( COMMA )? RPAREN ) + { + match(input,FROM,FOLLOW_FROM_in_import_from1818); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:12: ( ( DOT )* dotted_name | ( DOT )+ ) + int alt45=2; + alt45 = dfa45.predict(input); + switch (alt45) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:13: ( DOT )* dotted_name + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:13: ( DOT )* + loop43: + do { + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==DOT) ) { + alt43=1; + } + + + switch (alt43) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:13: DOT + { + match(input,DOT,FOLLOW_DOT_in_import_from1821); if (state.failed) return ; + + } + break; + + default : + break loop43; + } + } while (true); + + pushFollow(FOLLOW_dotted_name_in_import_from1824); + dotted_name(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:32: ( DOT )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:32: ( DOT )+ + int cnt44=0; + loop44: + do { + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==DOT) ) { + alt44=1; + } + + + switch (alt44) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:440:32: DOT + { + match(input,DOT,FOLLOW_DOT_in_import_from1828); if (state.failed) return ; + + } + break; + + default : + if ( cnt44 >= 1 ) break loop44; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(44, input); + throw eee; + } + cnt44++; + } while (true); + + + } + break; + + } + + match(input,IMPORT,FOLLOW_IMPORT_in_import_from1832); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:441:9: ( STAR | import_as_names | LPAREN import_as_names ( COMMA )? RPAREN ) + int alt47=3; + switch ( input.LA(1) ) { + case STAR: + { + alt47=1; + } + break; + case NAME: + { + alt47=2; + } + break; + case LPAREN: + { + alt47=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 47, 0, input); + + throw nvae; + } + + switch (alt47) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:441:10: STAR + { + match(input,STAR,FOLLOW_STAR_in_import_from1843); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:442:11: import_as_names + { + pushFollow(FOLLOW_import_as_names_in_import_from1855); + import_as_names(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:443:11: LPAREN import_as_names ( COMMA )? RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_import_from1867); if (state.failed) return ; + pushFollow(FOLLOW_import_as_names_in_import_from1869); + import_as_names(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:443:34: ( COMMA )? + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==COMMA) ) { + alt46=1; + } + switch (alt46) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:443:34: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_import_from1871); if (state.failed) return ; + + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_import_from1874); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "import_from" + + + // $ANTLR start "import_as_names" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:448:1: import_as_names : import_as_name ( COMMA import_as_name )* ; + public final void import_as_names() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:449:5: ( import_as_name ( COMMA import_as_name )* ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:449:7: import_as_name ( COMMA import_as_name )* + { + pushFollow(FOLLOW_import_as_name_in_import_as_names1902); + import_as_name(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:449:22: ( COMMA import_as_name )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==COMMA) ) { + int LA48_2 = input.LA(2); + + if ( (LA48_2==NAME) ) { + alt48=1; + } + + + } + + + switch (alt48) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:449:23: COMMA import_as_name + { + match(input,COMMA,FOLLOW_COMMA_in_import_as_names1905); if (state.failed) return ; + pushFollow(FOLLOW_import_as_name_in_import_as_names1907); + import_as_name(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop48; + } + } while (true); + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "import_as_names" + + + // $ANTLR start "import_as_name" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:453:1: import_as_name : NAME ( AS NAME )? ; + public final void import_as_name() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:454:5: ( NAME ( AS NAME )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:454:7: NAME ( AS NAME )? + { + match(input,NAME,FOLLOW_NAME_in_import_as_name1927); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:454:12: ( AS NAME )? + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==AS) ) { + alt49=1; + } + switch (alt49) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:454:13: AS NAME + { + match(input,AS,FOLLOW_AS_in_import_as_name1930); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_import_as_name1932); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "import_as_name" + + + // $ANTLR start "dotted_as_name" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:459:1: dotted_as_name : dotted_name ( AS NAME )? ; + public final void dotted_as_name() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:460:5: ( dotted_name ( AS NAME )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:460:7: dotted_name ( AS NAME )? + { + pushFollow(FOLLOW_dotted_name_in_dotted_as_name1953); + dotted_name(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:460:19: ( AS NAME )? + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==AS) ) { + alt50=1; + } + switch (alt50) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:460:20: AS NAME + { + match(input,AS,FOLLOW_AS_in_dotted_as_name1956); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_dotted_as_name1958); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "dotted_as_name" + + + // $ANTLR start "dotted_as_names" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:464:1: dotted_as_names : dotted_as_name ( COMMA dotted_as_name )* ; + public final void dotted_as_names() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:465:5: ( dotted_as_name ( COMMA dotted_as_name )* ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:465:7: dotted_as_name ( COMMA dotted_as_name )* + { + pushFollow(FOLLOW_dotted_as_name_in_dotted_as_names1978); + dotted_as_name(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:465:22: ( COMMA dotted_as_name )* + loop51: + do { + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==COMMA) ) { + alt51=1; + } + + + switch (alt51) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:465:23: COMMA dotted_as_name + { + match(input,COMMA,FOLLOW_COMMA_in_dotted_as_names1981); if (state.failed) return ; + pushFollow(FOLLOW_dotted_as_name_in_dotted_as_names1983); + dotted_as_name(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop51; + } + } while (true); + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "dotted_as_names" + + + // $ANTLR start "dotted_name" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:469:1: dotted_name : NAME ( DOT attr )* ; + public final void dotted_name() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:470:5: ( NAME ( DOT attr )* ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:470:7: NAME ( DOT attr )* + { + match(input,NAME,FOLLOW_NAME_in_dotted_name2003); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:470:12: ( DOT attr )* + loop52: + do { + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==DOT) ) { + alt52=1; + } + + + switch (alt52) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:470:13: DOT attr + { + match(input,DOT,FOLLOW_DOT_in_dotted_name2006); if (state.failed) return ; + pushFollow(FOLLOW_attr_in_dotted_name2008); + attr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop52; + } + } while (true); + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "dotted_name" + + + // $ANTLR start "global_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:474:1: global_stmt : GLOBAL NAME ( COMMA NAME )* ; + public final void global_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:475:5: ( GLOBAL NAME ( COMMA NAME )* ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:475:7: GLOBAL NAME ( COMMA NAME )* + { + match(input,GLOBAL,FOLLOW_GLOBAL_in_global_stmt2028); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_global_stmt2030); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:475:19: ( COMMA NAME )* + loop53: + do { + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==COMMA) ) { + alt53=1; + } + + + switch (alt53) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:475:20: COMMA NAME + { + match(input,COMMA,FOLLOW_COMMA_in_global_stmt2033); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_global_stmt2035); if (state.failed) return ; + + } + break; + + default : + break loop53; + } + } while (true); + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "global_stmt" + + + // $ANTLR start "exec_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:479:1: exec_stmt : EXEC expr ( IN test ( COMMA test )? )? ; + public final void exec_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:5: ( EXEC expr ( IN test ( COMMA test )? )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:7: EXEC expr ( IN test ( COMMA test )? )? + { + match(input,EXEC,FOLLOW_EXEC_in_exec_stmt2055); if (state.failed) return ; + pushFollow(FOLLOW_expr_in_exec_stmt2057); + expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:17: ( IN test ( COMMA test )? )? + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==IN) ) { + alt55=1; + } + switch (alt55) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:18: IN test ( COMMA test )? + { + match(input,IN,FOLLOW_IN_in_exec_stmt2060); if (state.failed) return ; + pushFollow(FOLLOW_test_in_exec_stmt2062); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:26: ( COMMA test )? + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==COMMA) ) { + alt54=1; + } + switch (alt54) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:480:27: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_exec_stmt2065); if (state.failed) return ; + pushFollow(FOLLOW_test_in_exec_stmt2067); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "exec_stmt" + + + // $ANTLR start "assert_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:484:1: assert_stmt : ASSERT test ( COMMA test )? ; + public final void assert_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:485:5: ( ASSERT test ( COMMA test )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:485:7: ASSERT test ( COMMA test )? + { + match(input,ASSERT,FOLLOW_ASSERT_in_assert_stmt2089); if (state.failed) return ; + pushFollow(FOLLOW_test_in_assert_stmt2091); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:485:19: ( COMMA test )? + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==COMMA) ) { + alt56=1; + } + switch (alt56) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:485:20: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_assert_stmt2094); if (state.failed) return ; + pushFollow(FOLLOW_test_in_assert_stmt2096); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "assert_stmt" + + + // $ANTLR start "compound_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:489:1: compound_stmt : ( if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | ( ( decorators )? DEF )=> funcdef | ( ( decorators )? CLASS )=> classdef | decorators ); + public final void compound_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:490:5: ( if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | ( ( decorators )? DEF )=> funcdef | ( ( decorators )? CLASS )=> classdef | decorators ) + int alt57=8; + alt57 = dfa57.predict(input); + switch (alt57) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:490:7: if_stmt + { + pushFollow(FOLLOW_if_stmt_in_compound_stmt2116); + if_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:491:7: while_stmt + { + pushFollow(FOLLOW_while_stmt_in_compound_stmt2124); + while_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:492:7: for_stmt + { + pushFollow(FOLLOW_for_stmt_in_compound_stmt2132); + for_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:493:7: try_stmt + { + pushFollow(FOLLOW_try_stmt_in_compound_stmt2140); + try_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:494:7: with_stmt + { + pushFollow(FOLLOW_with_stmt_in_compound_stmt2148); + with_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:495:7: ( ( decorators )? DEF )=> funcdef + { + pushFollow(FOLLOW_funcdef_in_compound_stmt2165); + funcdef(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:496:7: ( ( decorators )? CLASS )=> classdef + { + pushFollow(FOLLOW_classdef_in_compound_stmt2182); + classdef(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:497:7: decorators + { + pushFollow(FOLLOW_decorators_in_compound_stmt2190); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "compound_stmt" + + + // $ANTLR start "if_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:501:1: if_stmt : IF test COLON suite ( elif_clause )? ; + public final void if_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:502:5: ( IF test COLON suite ( elif_clause )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:502:7: IF test COLON suite ( elif_clause )? + { + match(input,IF,FOLLOW_IF_in_if_stmt2208); if (state.failed) return ; + pushFollow(FOLLOW_test_in_if_stmt2210); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_if_stmt2212); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_if_stmt2214); + suite(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:502:27: ( elif_clause )? + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==ELIF||LA58_0==ORELSE) ) { + alt58=1; + } + switch (alt58) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:502:27: elif_clause + { + pushFollow(FOLLOW_elif_clause_in_if_stmt2216); + elif_clause(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "if_stmt" + + + // $ANTLR start "elif_clause" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:506:1: elif_clause : ( else_clause | ELIF test COLON suite ( elif_clause | ) ); + public final void elif_clause() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:507:5: ( else_clause | ELIF test COLON suite ( elif_clause | ) ) + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==ORELSE) ) { + alt60=1; + } + else if ( (LA60_0==ELIF) ) { + alt60=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 60, 0, input); + + throw nvae; + } + switch (alt60) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:507:7: else_clause + { + pushFollow(FOLLOW_else_clause_in_elif_clause2235); + else_clause(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:508:7: ELIF test COLON suite ( elif_clause | ) + { + match(input,ELIF,FOLLOW_ELIF_in_elif_clause2243); if (state.failed) return ; + pushFollow(FOLLOW_test_in_elif_clause2245); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_elif_clause2247); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_elif_clause2249); + suite(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:509:9: ( elif_clause | ) + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==ELIF||LA59_0==ORELSE) ) { + alt59=1; + } + else if ( (LA59_0==EOF||(LA59_0>=DEDENT && LA59_0<=NEWLINE)||LA59_0==NAME||LA59_0==PRINT||(LA59_0>=ASSERT && LA59_0<=DELETE)||LA59_0==EXEC||(LA59_0>=FROM && LA59_0<=IMPORT)||(LA59_0>=LAMBDA && LA59_0<=NOT)||(LA59_0>=PASS && LA59_0<=LPAREN)||(LA59_0>=PLUS && LA59_0<=MINUS)||(LA59_0>=TILDE && LA59_0<=LBRACK)||LA59_0==LCURLY||(LA59_0>=BACKQUOTE && LA59_0<=STRING)||(LA59_0>=TRISTRINGPART && LA59_0<=STRINGPART)) ) { + alt59=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 59, 0, input); + + throw nvae; + } + switch (alt59) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:509:10: elif_clause + { + pushFollow(FOLLOW_elif_clause_in_elif_clause2260); + elif_clause(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:511:9: + { + } + break; + + } + + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "elif_clause" + + + // $ANTLR start "else_clause" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:515:1: else_clause : ORELSE COLON suite ; + public final void else_clause() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:516:5: ( ORELSE COLON suite ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:516:7: ORELSE COLON suite + { + match(input,ORELSE,FOLLOW_ORELSE_in_else_clause2298); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_else_clause2300); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_else_clause2302); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "else_clause" + + + // $ANTLR start "while_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:520:1: while_stmt : WHILE test COLON suite ( ORELSE COLON suite )? ; + public final void while_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:521:5: ( WHILE test COLON suite ( ORELSE COLON suite )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:521:7: WHILE test COLON suite ( ORELSE COLON suite )? + { + match(input,WHILE,FOLLOW_WHILE_in_while_stmt2320); if (state.failed) return ; + pushFollow(FOLLOW_test_in_while_stmt2322); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_while_stmt2324); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_while_stmt2326); + suite(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:521:30: ( ORELSE COLON suite )? + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==ORELSE) ) { + alt61=1; + } + switch (alt61) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:521:31: ORELSE COLON suite + { + match(input,ORELSE,FOLLOW_ORELSE_in_while_stmt2329); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_while_stmt2331); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_while_stmt2333); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "while_stmt" + + + // $ANTLR start "for_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:525:1: for_stmt : FOR exprlist IN testlist COLON suite ( ORELSE COLON suite )? ; + public final void for_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:526:5: ( FOR exprlist IN testlist COLON suite ( ORELSE COLON suite )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:526:7: FOR exprlist IN testlist COLON suite ( ORELSE COLON suite )? + { + match(input,FOR,FOLLOW_FOR_in_for_stmt2353); if (state.failed) return ; + pushFollow(FOLLOW_exprlist_in_for_stmt2355); + exprlist(); + + state._fsp--; + if (state.failed) return ; + match(input,IN,FOLLOW_IN_in_for_stmt2357); if (state.failed) return ; + pushFollow(FOLLOW_testlist_in_for_stmt2359); + testlist(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_for_stmt2361); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_for_stmt2363); + suite(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:527:9: ( ORELSE COLON suite )? + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==ORELSE) ) { + alt62=1; + } + switch (alt62) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:527:10: ORELSE COLON suite + { + match(input,ORELSE,FOLLOW_ORELSE_in_for_stmt2374); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_for_stmt2376); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_for_stmt2378); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "for_stmt" + + + // $ANTLR start "try_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:535:1: try_stmt : TRY COLON suite ( ( except_clause )+ ( ORELSE COLON suite )? ( FINALLY COLON suite )? | FINALLY COLON suite )? ; + public final void try_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:536:5: ( TRY COLON suite ( ( except_clause )+ ( ORELSE COLON suite )? ( FINALLY COLON suite )? | FINALLY COLON suite )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:536:7: TRY COLON suite ( ( except_clause )+ ( ORELSE COLON suite )? ( FINALLY COLON suite )? | FINALLY COLON suite )? + { + match(input,TRY,FOLLOW_TRY_in_try_stmt2402); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_try_stmt2404); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_try_stmt2406); + suite(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:7: ( ( except_clause )+ ( ORELSE COLON suite )? ( FINALLY COLON suite )? | FINALLY COLON suite )? + int alt66=3; + int LA66_0 = input.LA(1); + + if ( (LA66_0==EXCEPT) ) { + alt66=1; + } + else if ( (LA66_0==FINALLY) ) { + alt66=2; + } + switch (alt66) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:9: ( except_clause )+ ( ORELSE COLON suite )? ( FINALLY COLON suite )? + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:9: ( except_clause )+ + int cnt63=0; + loop63: + do { + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==EXCEPT) ) { + alt63=1; + } + + + switch (alt63) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:9: except_clause + { + pushFollow(FOLLOW_except_clause_in_try_stmt2416); + except_clause(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt63 >= 1 ) break loop63; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(63, input); + throw eee; + } + cnt63++; + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:24: ( ORELSE COLON suite )? + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==ORELSE) ) { + alt64=1; + } + switch (alt64) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:25: ORELSE COLON suite + { + match(input,ORELSE,FOLLOW_ORELSE_in_try_stmt2420); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_try_stmt2422); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_try_stmt2424); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:46: ( FINALLY COLON suite )? + int alt65=2; + int LA65_0 = input.LA(1); + + if ( (LA65_0==FINALLY) ) { + alt65=1; + } + switch (alt65) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:537:47: FINALLY COLON suite + { + match(input,FINALLY,FOLLOW_FINALLY_in_try_stmt2429); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_try_stmt2431); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_try_stmt2433); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:538:9: FINALLY COLON suite + { + match(input,FINALLY,FOLLOW_FINALLY_in_try_stmt2445); if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_try_stmt2447); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_try_stmt2449); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "try_stmt" + + + // $ANTLR start "with_stmt" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:543:1: with_stmt : WITH with_item ( options {greedy=true; } : COMMA with_item )* COLON suite ; + public final void with_stmt() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:544:5: ( WITH with_item ( options {greedy=true; } : COMMA with_item )* COLON suite ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:544:7: WITH with_item ( options {greedy=true; } : COMMA with_item )* COLON suite + { + match(input,WITH,FOLLOW_WITH_in_with_stmt2478); if (state.failed) return ; + pushFollow(FOLLOW_with_item_in_with_stmt2480); + with_item(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:544:22: ( options {greedy=true; } : COMMA with_item )* + loop67: + do { + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==COMMA) ) { + alt67=1; + } + + + switch (alt67) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:544:46: COMMA with_item + { + match(input,COMMA,FOLLOW_COMMA_in_with_stmt2490); if (state.failed) return ; + pushFollow(FOLLOW_with_item_in_with_stmt2492); + with_item(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop67; + } + } while (true); + + match(input,COLON,FOLLOW_COLON_in_with_stmt2496); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_with_stmt2498); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "with_stmt" + + + // $ANTLR start "with_item" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:548:1: with_item : test ( AS expr )? ; + public final void with_item() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:549:5: ( test ( AS expr )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:549:7: test ( AS expr )? + { + pushFollow(FOLLOW_test_in_with_item2516); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:549:12: ( AS expr )? + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==AS) ) { + alt68=1; + } + switch (alt68) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:549:13: AS expr + { + match(input,AS,FOLLOW_AS_in_with_item2519); if (state.failed) return ; + pushFollow(FOLLOW_expr_in_with_item2521); + expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "with_item" + + + // $ANTLR start "except_clause" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:553:1: except_clause : EXCEPT ( test ( ( COMMA | AS ) test )? )? COLON suite ; + public final void except_clause() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:5: ( EXCEPT ( test ( ( COMMA | AS ) test )? )? COLON suite ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:7: EXCEPT ( test ( ( COMMA | AS ) test )? )? COLON suite + { + match(input,EXCEPT,FOLLOW_EXCEPT_in_except_clause2541); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:14: ( test ( ( COMMA | AS ) test )? )? + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==TRAILBACKSLASH||LA70_0==NAME||(LA70_0>=LAMBDA && LA70_0<=NOT)||LA70_0==LPAREN||(LA70_0>=PLUS && LA70_0<=MINUS)||(LA70_0>=TILDE && LA70_0<=LBRACK)||LA70_0==LCURLY||(LA70_0>=BACKQUOTE && LA70_0<=STRING)||(LA70_0>=TRISTRINGPART && LA70_0<=STRINGPART)) ) { + alt70=1; + } + switch (alt70) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:15: test ( ( COMMA | AS ) test )? + { + pushFollow(FOLLOW_test_in_except_clause2544); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:20: ( ( COMMA | AS ) test )? + int alt69=2; + int LA69_0 = input.LA(1); + + if ( (LA69_0==AS||LA69_0==COMMA) ) { + alt69=1; + } + switch (alt69) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:554:21: ( COMMA | AS ) test + { + if ( input.LA(1)==AS||input.LA(1)==COMMA ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + pushFollow(FOLLOW_test_in_except_clause2555); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + match(input,COLON,FOLLOW_COLON_in_except_clause2561); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_except_clause2563); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "except_clause" + + + // $ANTLR start "suite" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:558:1: suite : ( simple_stmt | NEWLINE ( EOF | ( DEDENT )+ EOF | INDENT ( stmt )+ ( DEDENT | EOF ) ) ); + public final void suite() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:559:5: ( simple_stmt | NEWLINE ( EOF | ( DEDENT )+ EOF | INDENT ( stmt )+ ( DEDENT | EOF ) ) ) + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==TRAILBACKSLASH||LA74_0==NAME||LA74_0==PRINT||(LA74_0>=ASSERT && LA74_0<=BREAK)||LA74_0==CONTINUE||LA74_0==DELETE||LA74_0==EXEC||LA74_0==FROM||LA74_0==GLOBAL||LA74_0==IMPORT||(LA74_0>=LAMBDA && LA74_0<=NOT)||(LA74_0>=PASS && LA74_0<=RETURN)||LA74_0==YIELD||LA74_0==LPAREN||(LA74_0>=PLUS && LA74_0<=MINUS)||(LA74_0>=TILDE && LA74_0<=LBRACK)||LA74_0==LCURLY||(LA74_0>=BACKQUOTE && LA74_0<=STRING)||(LA74_0>=TRISTRINGPART && LA74_0<=STRINGPART)) ) { + alt74=1; + } + else if ( (LA74_0==NEWLINE) ) { + alt74=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 74, 0, input); + + throw nvae; + } + switch (alt74) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:559:7: simple_stmt + { + pushFollow(FOLLOW_simple_stmt_in_suite2581); + simple_stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:560:7: NEWLINE ( EOF | ( DEDENT )+ EOF | INDENT ( stmt )+ ( DEDENT | EOF ) ) + { + match(input,NEWLINE,FOLLOW_NEWLINE_in_suite2589); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:560:15: ( EOF | ( DEDENT )+ EOF | INDENT ( stmt )+ ( DEDENT | EOF ) ) + int alt73=3; + switch ( input.LA(1) ) { + case EOF: + { + alt73=1; + } + break; + case DEDENT: + { + alt73=2; + } + break; + case INDENT: + { + alt73=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 73, 0, input); + + throw nvae; + } + + switch (alt73) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:560:16: EOF + { + match(input,EOF,FOLLOW_EOF_in_suite2592); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:561:17: ( DEDENT )+ EOF + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:561:17: ( DEDENT )+ + int cnt71=0; + loop71: + do { + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==DEDENT) ) { + alt71=1; + } + + + switch (alt71) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:561:18: DEDENT + { + match(input,DEDENT,FOLLOW_DEDENT_in_suite2611); if (state.failed) return ; + + } + break; + + default : + if ( cnt71 >= 1 ) break loop71; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(71, input); + throw eee; + } + cnt71++; + } while (true); + + match(input,EOF,FOLLOW_EOF_in_suite2615); if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:562:17: INDENT ( stmt )+ ( DEDENT | EOF ) + { + match(input,INDENT,FOLLOW_INDENT_in_suite2633); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:562:24: ( stmt )+ + int cnt72=0; + loop72: + do { + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==TRAILBACKSLASH||LA72_0==NAME||LA72_0==PRINT||(LA72_0>=ASSERT && LA72_0<=DELETE)||LA72_0==EXEC||(LA72_0>=FROM && LA72_0<=IMPORT)||(LA72_0>=LAMBDA && LA72_0<=NOT)||(LA72_0>=PASS && LA72_0<=LPAREN)||(LA72_0>=PLUS && LA72_0<=MINUS)||(LA72_0>=TILDE && LA72_0<=LBRACK)||LA72_0==LCURLY||(LA72_0>=BACKQUOTE && LA72_0<=STRING)||(LA72_0>=TRISTRINGPART && LA72_0<=STRINGPART)) ) { + alt72=1; + } + + + switch (alt72) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:562:25: stmt + { + pushFollow(FOLLOW_stmt_in_suite2636); + stmt(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt72 >= 1 ) break loop72; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(72, input); + throw eee; + } + cnt72++; + } while (true); + + if ( input.LA(1)==EOF||input.LA(1)==DEDENT ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + break; + + } + + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "suite" + + + // $ANTLR start "test" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:569:1: test : ( or_test ( ( IF or_test ORELSE )=> IF or_test ORELSE test | ) | lambdef ); + public final void test() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:570:5: ( or_test ( ( IF or_test ORELSE )=> IF or_test ORELSE test | ) | lambdef ) + int alt76=2; + int LA76_0 = input.LA(1); + + if ( (LA76_0==TRAILBACKSLASH||LA76_0==NAME||LA76_0==NOT||LA76_0==LPAREN||(LA76_0>=PLUS && LA76_0<=MINUS)||(LA76_0>=TILDE && LA76_0<=LBRACK)||LA76_0==LCURLY||(LA76_0>=BACKQUOTE && LA76_0<=STRING)||(LA76_0>=TRISTRINGPART && LA76_0<=STRINGPART)) ) { + alt76=1; + } + else if ( (LA76_0==LAMBDA) ) { + alt76=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 76, 0, input); + + throw nvae; + } + switch (alt76) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:570:6: or_test ( ( IF or_test ORELSE )=> IF or_test ORELSE test | ) + { + pushFollow(FOLLOW_or_test_in_test2741); + or_test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:571:7: ( ( IF or_test ORELSE )=> IF or_test ORELSE test | ) + int alt75=2; + alt75 = dfa75.predict(input); + switch (alt75) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:571:9: ( IF or_test ORELSE )=> IF or_test ORELSE test + { + match(input,IF,FOLLOW_IF_in_test2761); if (state.failed) return ; + pushFollow(FOLLOW_or_test_in_test2763); + or_test(); + + state._fsp--; + if (state.failed) return ; + match(input,ORELSE,FOLLOW_ORELSE_in_test2765); if (state.failed) return ; + pushFollow(FOLLOW_test_in_test2767); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:573:7: + { + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:574:7: lambdef + { + pushFollow(FOLLOW_lambdef_in_test2791); + lambdef(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "test" + + + // $ANTLR start "or_test" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:578:1: or_test : and_test ( ( OR and_test )+ | ) ; + public final void or_test() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:579:5: ( and_test ( ( OR and_test )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:579:7: and_test ( ( OR and_test )+ | ) + { + pushFollow(FOLLOW_and_test_in_or_test2809); + and_test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:580:9: ( ( OR and_test )+ | ) + int alt78=2; + int LA78_0 = input.LA(1); + + if ( (LA78_0==OR) ) { + alt78=1; + } + else if ( (LA78_0==EOF||LA78_0==NEWLINE||LA78_0==AS||LA78_0==FOR||LA78_0==IF||LA78_0==ORELSE||(LA78_0>=RPAREN && LA78_0<=COMMA)||(LA78_0>=SEMI && LA78_0<=DOUBLESLASHEQUAL)||LA78_0==RBRACK||(LA78_0>=RCURLY && LA78_0<=BACKQUOTE)) ) { + alt78=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 78, 0, input); + + throw nvae; + } + switch (alt78) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:580:11: ( OR and_test )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:580:11: ( OR and_test )+ + int cnt77=0; + loop77: + do { + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==OR) ) { + alt77=1; + } + + + switch (alt77) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:580:12: OR and_test + { + match(input,OR,FOLLOW_OR_in_or_test2822); if (state.failed) return ; + pushFollow(FOLLOW_and_test_in_or_test2824); + and_test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt77 >= 1 ) break loop77; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(77, input); + throw eee; + } + cnt77++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:583:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "or_test" + + + // $ANTLR start "and_test" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:587:1: and_test : not_test ( ( AND not_test )+ | ) ; + public final void and_test() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:588:5: ( not_test ( ( AND not_test )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:588:7: not_test ( ( AND not_test )+ | ) + { + pushFollow(FOLLOW_not_test_in_and_test2875); + not_test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:589:9: ( ( AND not_test )+ | ) + int alt80=2; + int LA80_0 = input.LA(1); + + if ( (LA80_0==AND) ) { + alt80=1; + } + else if ( (LA80_0==EOF||LA80_0==NEWLINE||LA80_0==AS||LA80_0==FOR||LA80_0==IF||(LA80_0>=OR && LA80_0<=ORELSE)||(LA80_0>=RPAREN && LA80_0<=COMMA)||(LA80_0>=SEMI && LA80_0<=DOUBLESLASHEQUAL)||LA80_0==RBRACK||(LA80_0>=RCURLY && LA80_0<=BACKQUOTE)) ) { + alt80=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 80, 0, input); + + throw nvae; + } + switch (alt80) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:589:11: ( AND not_test )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:589:11: ( AND not_test )+ + int cnt79=0; + loop79: + do { + int alt79=2; + int LA79_0 = input.LA(1); + + if ( (LA79_0==AND) ) { + alt79=1; + } + + + switch (alt79) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:589:12: AND not_test + { + match(input,AND,FOLLOW_AND_in_and_test2888); if (state.failed) return ; + pushFollow(FOLLOW_not_test_in_and_test2890); + not_test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt79 >= 1 ) break loop79; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(79, input); + throw eee; + } + cnt79++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:592:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "and_test" + + + // $ANTLR start "not_test" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:596:1: not_test : ( NOT not_test | comparison ); + public final void not_test() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:597:5: ( NOT not_test | comparison ) + int alt81=2; + int LA81_0 = input.LA(1); + + if ( (LA81_0==NOT) ) { + alt81=1; + } + else if ( (LA81_0==TRAILBACKSLASH||LA81_0==NAME||LA81_0==LPAREN||(LA81_0>=PLUS && LA81_0<=MINUS)||(LA81_0>=TILDE && LA81_0<=LBRACK)||LA81_0==LCURLY||(LA81_0>=BACKQUOTE && LA81_0<=STRING)||(LA81_0>=TRISTRINGPART && LA81_0<=STRINGPART)) ) { + alt81=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 81, 0, input); + + throw nvae; + } + switch (alt81) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:597:7: NOT not_test + { + match(input,NOT,FOLLOW_NOT_in_not_test2941); if (state.failed) return ; + pushFollow(FOLLOW_not_test_in_not_test2943); + not_test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:598:7: comparison + { + pushFollow(FOLLOW_comparison_in_not_test2951); + comparison(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "not_test" + + + // $ANTLR start "comparison" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:602:1: comparison : expr ( ( comp_op expr )+ | ) ; + public final void comparison() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:603:5: ( expr ( ( comp_op expr )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:603:7: expr ( ( comp_op expr )+ | ) + { + pushFollow(FOLLOW_expr_in_comparison2969); + expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:604:8: ( ( comp_op expr )+ | ) + int alt83=2; + int LA83_0 = input.LA(1); + + if ( ((LA83_0>=IN && LA83_0<=IS)||LA83_0==NOT||(LA83_0>=LESS && LA83_0<=NOTEQUAL)) ) { + alt83=1; + } + else if ( (LA83_0==EOF||LA83_0==NEWLINE||(LA83_0>=AND && LA83_0<=AS)||LA83_0==FOR||LA83_0==IF||(LA83_0>=OR && LA83_0<=ORELSE)||(LA83_0>=RPAREN && LA83_0<=COMMA)||(LA83_0>=SEMI && LA83_0<=DOUBLESLASHEQUAL)||LA83_0==RBRACK||(LA83_0>=RCURLY && LA83_0<=BACKQUOTE)) ) { + alt83=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 83, 0, input); + + throw nvae; + } + switch (alt83) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:604:10: ( comp_op expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:604:10: ( comp_op expr )+ + int cnt82=0; + loop82: + do { + int alt82=2; + int LA82_0 = input.LA(1); + + if ( ((LA82_0>=IN && LA82_0<=IS)||LA82_0==NOT||(LA82_0>=LESS && LA82_0<=NOTEQUAL)) ) { + alt82=1; + } + + + switch (alt82) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:604:12: comp_op expr + { + pushFollow(FOLLOW_comp_op_in_comparison2982); + comp_op(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_expr_in_comparison2984); + expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt82 >= 1 ) break loop82; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(82, input); + throw eee; + } + cnt82++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:607:8: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "comparison" + + + // $ANTLR start "comp_op" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:611:1: comp_op : ( LESS | GREATER | EQUAL | GREATEREQUAL | LESSEQUAL | ALT_NOTEQUAL | NOTEQUAL | IN | NOT IN | IS | IS NOT ); + public final void comp_op() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:612:5: ( LESS | GREATER | EQUAL | GREATEREQUAL | LESSEQUAL | ALT_NOTEQUAL | NOTEQUAL | IN | NOT IN | IS | IS NOT ) + int alt84=11; + alt84 = dfa84.predict(input); + switch (alt84) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:612:7: LESS + { + match(input,LESS,FOLLOW_LESS_in_comp_op3032); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:613:7: GREATER + { + match(input,GREATER,FOLLOW_GREATER_in_comp_op3040); if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:614:7: EQUAL + { + match(input,EQUAL,FOLLOW_EQUAL_in_comp_op3048); if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:615:7: GREATEREQUAL + { + match(input,GREATEREQUAL,FOLLOW_GREATEREQUAL_in_comp_op3056); if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:616:7: LESSEQUAL + { + match(input,LESSEQUAL,FOLLOW_LESSEQUAL_in_comp_op3064); if (state.failed) return ; + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:617:7: ALT_NOTEQUAL + { + match(input,ALT_NOTEQUAL,FOLLOW_ALT_NOTEQUAL_in_comp_op3072); if (state.failed) return ; + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:618:7: NOTEQUAL + { + match(input,NOTEQUAL,FOLLOW_NOTEQUAL_in_comp_op3080); if (state.failed) return ; + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:619:7: IN + { + match(input,IN,FOLLOW_IN_in_comp_op3088); if (state.failed) return ; + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:620:7: NOT IN + { + match(input,NOT,FOLLOW_NOT_in_comp_op3096); if (state.failed) return ; + match(input,IN,FOLLOW_IN_in_comp_op3098); if (state.failed) return ; + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:621:7: IS + { + match(input,IS,FOLLOW_IS_in_comp_op3106); if (state.failed) return ; + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:622:7: IS NOT + { + match(input,IS,FOLLOW_IS_in_comp_op3114); if (state.failed) return ; + match(input,NOT,FOLLOW_NOT_in_comp_op3116); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "comp_op" + + + // $ANTLR start "expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:626:1: expr : xor_expr ( ( VBAR xor_expr )+ | ) ; + public final void expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:627:5: ( xor_expr ( ( VBAR xor_expr )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:627:7: xor_expr ( ( VBAR xor_expr )+ | ) + { + pushFollow(FOLLOW_xor_expr_in_expr3134); + xor_expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:628:9: ( ( VBAR xor_expr )+ | ) + int alt86=2; + int LA86_0 = input.LA(1); + + if ( (LA86_0==VBAR) ) { + alt86=1; + } + else if ( (LA86_0==EOF||LA86_0==NEWLINE||(LA86_0>=AND && LA86_0<=AS)||LA86_0==FOR||LA86_0==IF||(LA86_0>=IN && LA86_0<=IS)||(LA86_0>=NOT && LA86_0<=ORELSE)||(LA86_0>=RPAREN && LA86_0<=COMMA)||(LA86_0>=SEMI && LA86_0<=DOUBLESLASHEQUAL)||(LA86_0>=LESS && LA86_0<=NOTEQUAL)||LA86_0==RBRACK||(LA86_0>=RCURLY && LA86_0<=BACKQUOTE)) ) { + alt86=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 86, 0, input); + + throw nvae; + } + switch (alt86) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:628:11: ( VBAR xor_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:628:11: ( VBAR xor_expr )+ + int cnt85=0; + loop85: + do { + int alt85=2; + int LA85_0 = input.LA(1); + + if ( (LA85_0==VBAR) ) { + alt85=1; + } + + + switch (alt85) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:628:12: VBAR xor_expr + { + match(input,VBAR,FOLLOW_VBAR_in_expr3147); if (state.failed) return ; + pushFollow(FOLLOW_xor_expr_in_expr3149); + xor_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt85 >= 1 ) break loop85; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(85, input); + throw eee; + } + cnt85++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:631:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "expr" + + + // $ANTLR start "xor_expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:635:1: xor_expr : and_expr ( ( CIRCUMFLEX and_expr )+ | ) ; + public final void xor_expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:636:5: ( and_expr ( ( CIRCUMFLEX and_expr )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:636:7: and_expr ( ( CIRCUMFLEX and_expr )+ | ) + { + pushFollow(FOLLOW_and_expr_in_xor_expr3200); + and_expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:637:9: ( ( CIRCUMFLEX and_expr )+ | ) + int alt88=2; + int LA88_0 = input.LA(1); + + if ( (LA88_0==CIRCUMFLEX) ) { + alt88=1; + } + else if ( (LA88_0==EOF||LA88_0==NEWLINE||(LA88_0>=AND && LA88_0<=AS)||LA88_0==FOR||LA88_0==IF||(LA88_0>=IN && LA88_0<=IS)||(LA88_0>=NOT && LA88_0<=ORELSE)||(LA88_0>=RPAREN && LA88_0<=COMMA)||(LA88_0>=SEMI && LA88_0<=DOUBLESLASHEQUAL)||(LA88_0>=LESS && LA88_0<=VBAR)||LA88_0==RBRACK||(LA88_0>=RCURLY && LA88_0<=BACKQUOTE)) ) { + alt88=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 88, 0, input); + + throw nvae; + } + switch (alt88) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:637:11: ( CIRCUMFLEX and_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:637:11: ( CIRCUMFLEX and_expr )+ + int cnt87=0; + loop87: + do { + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==CIRCUMFLEX) ) { + alt87=1; + } + + + switch (alt87) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:637:12: CIRCUMFLEX and_expr + { + match(input,CIRCUMFLEX,FOLLOW_CIRCUMFLEX_in_xor_expr3213); if (state.failed) return ; + pushFollow(FOLLOW_and_expr_in_xor_expr3215); + and_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt87 >= 1 ) break loop87; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(87, input); + throw eee; + } + cnt87++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:640:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "xor_expr" + + + // $ANTLR start "and_expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:644:1: and_expr : shift_expr ( ( AMPER shift_expr )+ | ) ; + public final void and_expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:645:5: ( shift_expr ( ( AMPER shift_expr )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:645:7: shift_expr ( ( AMPER shift_expr )+ | ) + { + pushFollow(FOLLOW_shift_expr_in_and_expr3266); + shift_expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:646:9: ( ( AMPER shift_expr )+ | ) + int alt90=2; + int LA90_0 = input.LA(1); + + if ( (LA90_0==AMPER) ) { + alt90=1; + } + else if ( (LA90_0==EOF||LA90_0==NEWLINE||(LA90_0>=AND && LA90_0<=AS)||LA90_0==FOR||LA90_0==IF||(LA90_0>=IN && LA90_0<=IS)||(LA90_0>=NOT && LA90_0<=ORELSE)||(LA90_0>=RPAREN && LA90_0<=COMMA)||(LA90_0>=SEMI && LA90_0<=DOUBLESLASHEQUAL)||(LA90_0>=LESS && LA90_0<=CIRCUMFLEX)||LA90_0==RBRACK||(LA90_0>=RCURLY && LA90_0<=BACKQUOTE)) ) { + alt90=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 90, 0, input); + + throw nvae; + } + switch (alt90) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:646:11: ( AMPER shift_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:646:11: ( AMPER shift_expr )+ + int cnt89=0; + loop89: + do { + int alt89=2; + int LA89_0 = input.LA(1); + + if ( (LA89_0==AMPER) ) { + alt89=1; + } + + + switch (alt89) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:646:12: AMPER shift_expr + { + match(input,AMPER,FOLLOW_AMPER_in_and_expr3279); if (state.failed) return ; + pushFollow(FOLLOW_shift_expr_in_and_expr3281); + shift_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt89 >= 1 ) break loop89; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(89, input); + throw eee; + } + cnt89++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:649:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "and_expr" + + + // $ANTLR start "shift_expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:653:1: shift_expr : arith_expr ( ( shift_op arith_expr )+ | ) ; + public final void shift_expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:654:5: ( arith_expr ( ( shift_op arith_expr )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:654:7: arith_expr ( ( shift_op arith_expr )+ | ) + { + pushFollow(FOLLOW_arith_expr_in_shift_expr3332); + arith_expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:655:9: ( ( shift_op arith_expr )+ | ) + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==RIGHTSHIFT||LA92_0==LEFTSHIFT) ) { + alt92=1; + } + else if ( (LA92_0==EOF||LA92_0==NEWLINE||(LA92_0>=AND && LA92_0<=AS)||LA92_0==FOR||LA92_0==IF||(LA92_0>=IN && LA92_0<=IS)||(LA92_0>=NOT && LA92_0<=ORELSE)||(LA92_0>=RPAREN && LA92_0<=COMMA)||(LA92_0>=SEMI && LA92_0<=DOUBLESLASHEQUAL)||(LA92_0>=LESS && LA92_0<=AMPER)||LA92_0==RBRACK||(LA92_0>=RCURLY && LA92_0<=BACKQUOTE)) ) { + alt92=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 92, 0, input); + + throw nvae; + } + switch (alt92) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:655:11: ( shift_op arith_expr )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:655:11: ( shift_op arith_expr )+ + int cnt91=0; + loop91: + do { + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==RIGHTSHIFT||LA91_0==LEFTSHIFT) ) { + alt91=1; + } + + + switch (alt91) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:655:13: shift_op arith_expr + { + pushFollow(FOLLOW_shift_op_in_shift_expr3346); + shift_op(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_arith_expr_in_shift_expr3348); + arith_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt91 >= 1 ) break loop91; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(91, input); + throw eee; + } + cnt91++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:658:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "shift_expr" + + + // $ANTLR start "shift_op" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:661:1: shift_op : ( LEFTSHIFT | RIGHTSHIFT ); + public final void shift_op() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:662:5: ( LEFTSHIFT | RIGHTSHIFT ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)==RIGHTSHIFT||input.LA(1)==LEFTSHIFT ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "shift_op" + + + // $ANTLR start "arith_expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:667:1: arith_expr : term ( ( arith_op term )+ | ) ; + public final void arith_expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:668:5: ( term ( ( arith_op term )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:668:7: term ( ( arith_op term )+ | ) + { + pushFollow(FOLLOW_term_in_arith_expr3424); + term(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:669:9: ( ( arith_op term )+ | ) + int alt94=2; + int LA94_0 = input.LA(1); + + if ( ((LA94_0>=PLUS && LA94_0<=MINUS)) ) { + alt94=1; + } + else if ( (LA94_0==EOF||LA94_0==NEWLINE||(LA94_0>=AND && LA94_0<=AS)||LA94_0==FOR||LA94_0==IF||(LA94_0>=IN && LA94_0<=IS)||(LA94_0>=NOT && LA94_0<=ORELSE)||(LA94_0>=RPAREN && LA94_0<=COMMA)||(LA94_0>=SEMI && LA94_0<=LEFTSHIFT)||LA94_0==RBRACK||(LA94_0>=RCURLY && LA94_0<=BACKQUOTE)) ) { + alt94=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 94, 0, input); + + throw nvae; + } + switch (alt94) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:669:11: ( arith_op term )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:669:11: ( arith_op term )+ + int cnt93=0; + loop93: + do { + int alt93=2; + int LA93_0 = input.LA(1); + + if ( ((LA93_0>=PLUS && LA93_0<=MINUS)) ) { + alt93=1; + } + + + switch (alt93) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:669:12: arith_op term + { + pushFollow(FOLLOW_arith_op_in_arith_expr3437); + arith_op(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_term_in_arith_expr3439); + term(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt93 >= 1 ) break loop93; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(93, input); + throw eee; + } + cnt93++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:672:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "arith_expr" + + + // $ANTLR start "arith_op" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:675:1: arith_op : ( PLUS | MINUS ); + public final void arith_op() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:676:5: ( PLUS | MINUS ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( (input.LA(1)>=PLUS && input.LA(1)<=MINUS) ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "arith_op" + + + // $ANTLR start "term" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:681:1: term : factor ( ( term_op factor )+ | ) ; + public final void term() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:682:5: ( factor ( ( term_op factor )+ | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:682:7: factor ( ( term_op factor )+ | ) + { + pushFollow(FOLLOW_factor_in_term3515); + factor(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:683:9: ( ( term_op factor )+ | ) + int alt96=2; + int LA96_0 = input.LA(1); + + if ( (LA96_0==STAR||(LA96_0>=SLASH && LA96_0<=DOUBLESLASH)) ) { + alt96=1; + } + else if ( (LA96_0==EOF||LA96_0==NEWLINE||(LA96_0>=AND && LA96_0<=AS)||LA96_0==FOR||LA96_0==IF||(LA96_0>=IN && LA96_0<=IS)||(LA96_0>=NOT && LA96_0<=ORELSE)||(LA96_0>=RPAREN && LA96_0<=COMMA)||(LA96_0>=SEMI && LA96_0<=MINUS)||LA96_0==RBRACK||(LA96_0>=RCURLY && LA96_0<=BACKQUOTE)) ) { + alt96=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 96, 0, input); + + throw nvae; + } + switch (alt96) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:683:11: ( term_op factor )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:683:11: ( term_op factor )+ + int cnt95=0; + loop95: + do { + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==STAR||(LA95_0>=SLASH && LA95_0<=DOUBLESLASH)) ) { + alt95=1; + } + + + switch (alt95) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:683:12: term_op factor + { + pushFollow(FOLLOW_term_op_in_term3528); + term_op(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_factor_in_term3530); + factor(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + if ( cnt95 >= 1 ) break loop95; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(95, input); + throw eee; + } + cnt95++; + } while (true); + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:686:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "term" + + + // $ANTLR start "term_op" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:689:1: term_op : ( STAR | SLASH | PERCENT | DOUBLESLASH ); + public final void term_op() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:690:5: ( STAR | SLASH | PERCENT | DOUBLESLASH ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g: + { + if ( input.LA(1)==STAR||(input.LA(1)>=SLASH && input.LA(1)<=DOUBLESLASH) ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "term_op" + + + // $ANTLR start "factor" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:697:1: factor : ( PLUS factor | MINUS factor | TILDE factor | power | TRAILBACKSLASH ); + public final void factor() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:698:5: ( PLUS factor | MINUS factor | TILDE factor | power | TRAILBACKSLASH ) + int alt97=5; + switch ( input.LA(1) ) { + case PLUS: + { + alt97=1; + } + break; + case MINUS: + { + alt97=2; + } + break; + case TILDE: + { + alt97=3; + } + break; + case NAME: + case LPAREN: + case LBRACK: + case LCURLY: + case BACKQUOTE: + case INT: + case LONGINT: + case FLOAT: + case COMPLEX: + case STRING: + case TRISTRINGPART: + case STRINGPART: + { + alt97=4; + } + break; + case TRAILBACKSLASH: + { + alt97=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 97, 0, input); + + throw nvae; + } + + switch (alt97) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:698:7: PLUS factor + { + match(input,PLUS,FOLLOW_PLUS_in_factor3618); if (state.failed) return ; + pushFollow(FOLLOW_factor_in_factor3620); + factor(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:699:7: MINUS factor + { + match(input,MINUS,FOLLOW_MINUS_in_factor3628); if (state.failed) return ; + pushFollow(FOLLOW_factor_in_factor3630); + factor(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:700:7: TILDE factor + { + match(input,TILDE,FOLLOW_TILDE_in_factor3638); if (state.failed) return ; + pushFollow(FOLLOW_factor_in_factor3640); + factor(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:701:7: power + { + pushFollow(FOLLOW_power_in_factor3648); + power(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:702:7: TRAILBACKSLASH + { + match(input,TRAILBACKSLASH,FOLLOW_TRAILBACKSLASH_in_factor3656); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "factor" + + + // $ANTLR start "power" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:706:1: power : atom ( trailer )* ( options {greedy=true; } : DOUBLESTAR factor )? ; + public final void power() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:5: ( atom ( trailer )* ( options {greedy=true; } : DOUBLESTAR factor )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:7: atom ( trailer )* ( options {greedy=true; } : DOUBLESTAR factor )? + { + pushFollow(FOLLOW_atom_in_power3674); + atom(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:12: ( trailer )* + loop98: + do { + int alt98=2; + int LA98_0 = input.LA(1); + + if ( (LA98_0==DOT||LA98_0==LPAREN||LA98_0==LBRACK) ) { + alt98=1; + } + + + switch (alt98) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:13: trailer + { + pushFollow(FOLLOW_trailer_in_power3677); + trailer(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop98; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:23: ( options {greedy=true; } : DOUBLESTAR factor )? + int alt99=2; + int LA99_0 = input.LA(1); + + if ( (LA99_0==DOUBLESTAR) ) { + alt99=1; + } + switch (alt99) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:707:47: DOUBLESTAR factor + { + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_power3689); if (state.failed) return ; + pushFollow(FOLLOW_factor_in_power3691); + factor(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "power" + + + // $ANTLR start "atom" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:715:1: atom : ( LPAREN ( yield_expr | testlist_gexp | ) RPAREN | LBRACK ( listmaker | ) RBRACK | LCURLY ( dictorsetmaker | ) RCURLY | BACKQUOTE testlist BACKQUOTE | NAME | INT | LONGINT | FLOAT | COMPLEX | ( STRING )+ | TRISTRINGPART | STRINGPART TRAILBACKSLASH ); + public final void atom() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:716:5: ( LPAREN ( yield_expr | testlist_gexp | ) RPAREN | LBRACK ( listmaker | ) RBRACK | LCURLY ( dictorsetmaker | ) RCURLY | BACKQUOTE testlist BACKQUOTE | NAME | INT | LONGINT | FLOAT | COMPLEX | ( STRING )+ | TRISTRINGPART | STRINGPART TRAILBACKSLASH ) + int alt104=12; + switch ( input.LA(1) ) { + case LPAREN: + { + alt104=1; + } + break; + case LBRACK: + { + alt104=2; + } + break; + case LCURLY: + { + alt104=3; + } + break; + case BACKQUOTE: + { + alt104=4; + } + break; + case NAME: + { + alt104=5; + } + break; + case INT: + { + alt104=6; + } + break; + case LONGINT: + { + alt104=7; + } + break; + case FLOAT: + { + alt104=8; + } + break; + case COMPLEX: + { + alt104=9; + } + break; + case STRING: + { + alt104=10; + } + break; + case TRISTRINGPART: + { + alt104=11; + } + break; + case STRINGPART: + { + alt104=12; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 104, 0, input); + + throw nvae; + } + + switch (alt104) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:716:7: LPAREN ( yield_expr | testlist_gexp | ) RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_atom3715); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:717:7: ( yield_expr | testlist_gexp | ) + int alt100=3; + switch ( input.LA(1) ) { + case YIELD: + { + alt100=1; + } + break; + case TRAILBACKSLASH: + case NAME: + case LAMBDA: + case NOT: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case LBRACK: + case LCURLY: + case BACKQUOTE: + case INT: + case LONGINT: + case FLOAT: + case COMPLEX: + case STRING: + case TRISTRINGPART: + case STRINGPART: + { + alt100=2; + } + break; + case RPAREN: + { + alt100=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 100, 0, input); + + throw nvae; + } + + switch (alt100) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:717:9: yield_expr + { + pushFollow(FOLLOW_yield_expr_in_atom3725); + yield_expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:718:9: testlist_gexp + { + pushFollow(FOLLOW_testlist_gexp_in_atom3735); + testlist_gexp(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:720:7: + { + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_atom3759); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:722:7: LBRACK ( listmaker | ) RBRACK + { + match(input,LBRACK,FOLLOW_LBRACK_in_atom3767); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:723:7: ( listmaker | ) + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==TRAILBACKSLASH||LA101_0==NAME||(LA101_0>=LAMBDA && LA101_0<=NOT)||LA101_0==LPAREN||(LA101_0>=PLUS && LA101_0<=MINUS)||(LA101_0>=TILDE && LA101_0<=LBRACK)||LA101_0==LCURLY||(LA101_0>=BACKQUOTE && LA101_0<=STRING)||(LA101_0>=TRISTRINGPART && LA101_0<=STRINGPART)) ) { + alt101=1; + } + else if ( (LA101_0==RBRACK) ) { + alt101=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 101, 0, input); + + throw nvae; + } + switch (alt101) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:723:8: listmaker + { + pushFollow(FOLLOW_listmaker_in_atom3776); + listmaker(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:725:7: + { + } + break; + + } + + match(input,RBRACK,FOLLOW_RBRACK_in_atom3800); if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:727:7: LCURLY ( dictorsetmaker | ) RCURLY + { + match(input,LCURLY,FOLLOW_LCURLY_in_atom3808); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:728:8: ( dictorsetmaker | ) + int alt102=2; + int LA102_0 = input.LA(1); + + if ( (LA102_0==TRAILBACKSLASH||LA102_0==NAME||(LA102_0>=LAMBDA && LA102_0<=NOT)||LA102_0==LPAREN||(LA102_0>=PLUS && LA102_0<=MINUS)||(LA102_0>=TILDE && LA102_0<=LBRACK)||LA102_0==LCURLY||(LA102_0>=BACKQUOTE && LA102_0<=STRING)||(LA102_0>=TRISTRINGPART && LA102_0<=STRINGPART)) ) { + alt102=1; + } + else if ( (LA102_0==RCURLY) ) { + alt102=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 102, 0, input); + + throw nvae; + } + switch (alt102) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:728:9: dictorsetmaker + { + pushFollow(FOLLOW_dictorsetmaker_in_atom3818); + dictorsetmaker(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:730:8: + { + } + break; + + } + + match(input,RCURLY,FOLLOW_RCURLY_in_atom3845); if (state.failed) return ; + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:732:8: BACKQUOTE testlist BACKQUOTE + { + match(input,BACKQUOTE,FOLLOW_BACKQUOTE_in_atom3854); if (state.failed) return ; + pushFollow(FOLLOW_testlist_in_atom3856); + testlist(); + + state._fsp--; + if (state.failed) return ; + match(input,BACKQUOTE,FOLLOW_BACKQUOTE_in_atom3858); if (state.failed) return ; + + } + break; + case 5 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:733:8: NAME + { + match(input,NAME,FOLLOW_NAME_in_atom3867); if (state.failed) return ; + + } + break; + case 6 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:734:8: INT + { + match(input,INT,FOLLOW_INT_in_atom3876); if (state.failed) return ; + + } + break; + case 7 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:735:8: LONGINT + { + match(input,LONGINT,FOLLOW_LONGINT_in_atom3885); if (state.failed) return ; + + } + break; + case 8 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:736:8: FLOAT + { + match(input,FLOAT,FOLLOW_FLOAT_in_atom3894); if (state.failed) return ; + + } + break; + case 9 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:737:8: COMPLEX + { + match(input,COMPLEX,FOLLOW_COMPLEX_in_atom3903); if (state.failed) return ; + + } + break; + case 10 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:738:8: ( STRING )+ + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:738:8: ( STRING )+ + int cnt103=0; + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( (LA103_0==STRING) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:738:9: STRING + { + match(input,STRING,FOLLOW_STRING_in_atom3913); if (state.failed) return ; + + } + break; + + default : + if ( cnt103 >= 1 ) break loop103; + if (state.backtracking>0) {state.failed=true; return ;} + EarlyExitException eee = + new EarlyExitException(103, input); + throw eee; + } + cnt103++; + } while (true); + + + } + break; + case 11 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:739:8: TRISTRINGPART + { + match(input,TRISTRINGPART,FOLLOW_TRISTRINGPART_in_atom3924); if (state.failed) return ; + + } + break; + case 12 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:740:8: STRINGPART TRAILBACKSLASH + { + match(input,STRINGPART,FOLLOW_STRINGPART_in_atom3933); if (state.failed) return ; + match(input,TRAILBACKSLASH,FOLLOW_TRAILBACKSLASH_in_atom3935); if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "atom" + + + // $ANTLR start "listmaker" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:744:1: listmaker : test ( list_for | ( options {greedy=true; } : COMMA test )* ) ( COMMA )? ; + public final void listmaker() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:745:5: ( test ( list_for | ( options {greedy=true; } : COMMA test )* ) ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:745:7: test ( list_for | ( options {greedy=true; } : COMMA test )* ) ( COMMA )? + { + pushFollow(FOLLOW_test_in_listmaker3954); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:746:9: ( list_for | ( options {greedy=true; } : COMMA test )* ) + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==FOR) ) { + alt106=1; + } + else if ( (LA106_0==COMMA||LA106_0==RBRACK) ) { + alt106=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 106, 0, input); + + throw nvae; + } + switch (alt106) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:746:10: list_for + { + pushFollow(FOLLOW_list_for_in_listmaker3965); + list_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:747:11: ( options {greedy=true; } : COMMA test )* + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:747:11: ( options {greedy=true; } : COMMA test )* + loop105: + do { + int alt105=2; + int LA105_0 = input.LA(1); + + if ( (LA105_0==COMMA) ) { + int LA105_1 = input.LA(2); + + if ( (LA105_1==TRAILBACKSLASH||LA105_1==NAME||(LA105_1>=LAMBDA && LA105_1<=NOT)||LA105_1==LPAREN||(LA105_1>=PLUS && LA105_1<=MINUS)||(LA105_1>=TILDE && LA105_1<=LBRACK)||LA105_1==LCURLY||(LA105_1>=BACKQUOTE && LA105_1<=STRING)||(LA105_1>=TRISTRINGPART && LA105_1<=STRINGPART)) ) { + alt105=1; + } + + + } + + + switch (alt105) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:747:35: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_listmaker3985); if (state.failed) return ; + pushFollow(FOLLOW_test_in_listmaker3987); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop105; + } + } while (true); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:748:11: ( COMMA )? + int alt107=2; + int LA107_0 = input.LA(1); + + if ( (LA107_0==COMMA) ) { + alt107=1; + } + switch (alt107) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:748:12: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_listmaker4002); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "listmaker" + + + // $ANTLR start "testlist_gexp" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:752:1: testlist_gexp : test ( ( ( options {k=2; } : COMMA test )* ( COMMA )? ) | ( comp_for ) ) ; + public final void testlist_gexp() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:753:5: ( test ( ( ( options {k=2; } : COMMA test )* ( COMMA )? ) | ( comp_for ) ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:753:7: test ( ( ( options {k=2; } : COMMA test )* ( COMMA )? ) | ( comp_for ) ) + { + pushFollow(FOLLOW_test_in_testlist_gexp4022); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:9: ( ( ( options {k=2; } : COMMA test )* ( COMMA )? ) | ( comp_for ) ) + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==RPAREN||LA110_0==COMMA) ) { + alt110=1; + } + else if ( (LA110_0==FOR) ) { + alt110=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 110, 0, input); + + throw nvae; + } + switch (alt110) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:11: ( ( options {k=2; } : COMMA test )* ( COMMA )? ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:11: ( ( options {k=2; } : COMMA test )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:12: ( options {k=2; } : COMMA test )* ( COMMA )? + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:12: ( options {k=2; } : COMMA test )* + loop108: + do { + int alt108=2; + alt108 = dfa108.predict(input); + switch (alt108) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:29: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_testlist_gexp4044); if (state.failed) return ; + pushFollow(FOLLOW_test_in_testlist_gexp4046); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop108; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:42: ( COMMA )? + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==COMMA) ) { + alt109=1; + } + switch (alt109) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:754:43: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_testlist_gexp4051); if (state.failed) return ; + + } + break; + + } + + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:756:11: ( comp_for ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:756:11: ( comp_for ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:756:12: comp_for + { + pushFollow(FOLLOW_comp_for_in_testlist_gexp4078); + comp_for(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "testlist_gexp" + + + // $ANTLR start "lambdef" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:762:1: lambdef : LAMBDA ( varargslist )? COLON test ; + public final void lambdef() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:763:5: ( LAMBDA ( varargslist )? COLON test ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:763:7: LAMBDA ( varargslist )? COLON test + { + match(input,LAMBDA,FOLLOW_LAMBDA_in_lambdef4118); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:763:14: ( varargslist )? + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==NAME||LA111_0==LPAREN||(LA111_0>=STAR && LA111_0<=DOUBLESTAR)) ) { + alt111=1; + } + switch (alt111) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:763:15: varargslist + { + pushFollow(FOLLOW_varargslist_in_lambdef4121); + varargslist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,COLON,FOLLOW_COLON_in_lambdef4125); if (state.failed) return ; + pushFollow(FOLLOW_test_in_lambdef4127); + test(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "lambdef" + + + // $ANTLR start "trailer" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:767:1: trailer : ( LPAREN ( arglist | ) RPAREN | LBRACK subscriptlist RBRACK | DOT attr ); + public final void trailer() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:768:5: ( LPAREN ( arglist | ) RPAREN | LBRACK subscriptlist RBRACK | DOT attr ) + int alt113=3; + switch ( input.LA(1) ) { + case LPAREN: + { + alt113=1; + } + break; + case LBRACK: + { + alt113=2; + } + break; + case DOT: + { + alt113=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 113, 0, input); + + throw nvae; + } + + switch (alt113) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:768:7: LPAREN ( arglist | ) RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_trailer4145); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:769:9: ( arglist | ) + int alt112=2; + int LA112_0 = input.LA(1); + + if ( (LA112_0==TRAILBACKSLASH||LA112_0==NAME||(LA112_0>=LAMBDA && LA112_0<=NOT)||LA112_0==LPAREN||(LA112_0>=STAR && LA112_0<=DOUBLESTAR)||(LA112_0>=PLUS && LA112_0<=MINUS)||(LA112_0>=TILDE && LA112_0<=LBRACK)||LA112_0==LCURLY||(LA112_0>=BACKQUOTE && LA112_0<=STRING)||(LA112_0>=TRISTRINGPART && LA112_0<=STRINGPART)) ) { + alt112=1; + } + else if ( (LA112_0==RPAREN) ) { + alt112=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 112, 0, input); + + throw nvae; + } + switch (alt112) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:769:10: arglist + { + pushFollow(FOLLOW_arglist_in_trailer4156); + arglist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:771:9: + { + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_trailer4184); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:773:7: LBRACK subscriptlist RBRACK + { + match(input,LBRACK,FOLLOW_LBRACK_in_trailer4192); if (state.failed) return ; + pushFollow(FOLLOW_subscriptlist_in_trailer4194); + subscriptlist(); + + state._fsp--; + if (state.failed) return ; + match(input,RBRACK,FOLLOW_RBRACK_in_trailer4196); if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:774:7: DOT attr + { + match(input,DOT,FOLLOW_DOT_in_trailer4204); if (state.failed) return ; + pushFollow(FOLLOW_attr_in_trailer4206); + attr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "trailer" + + + // $ANTLR start "subscriptlist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:778:1: subscriptlist : subscript ( options {greedy=true; } : COMMA subscript )* ( COMMA )? ; + public final void subscriptlist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:5: ( subscript ( options {greedy=true; } : COMMA subscript )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:7: subscript ( options {greedy=true; } : COMMA subscript )* ( COMMA )? + { + pushFollow(FOLLOW_subscript_in_subscriptlist4224); + subscript(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:17: ( options {greedy=true; } : COMMA subscript )* + loop114: + do { + int alt114=2; + int LA114_0 = input.LA(1); + + if ( (LA114_0==COMMA) ) { + int LA114_1 = input.LA(2); + + if ( (LA114_1==TRAILBACKSLASH||(LA114_1>=NAME && LA114_1<=DOT)||(LA114_1>=LAMBDA && LA114_1<=NOT)||LA114_1==LPAREN||LA114_1==COLON||(LA114_1>=PLUS && LA114_1<=MINUS)||(LA114_1>=TILDE && LA114_1<=LBRACK)||LA114_1==LCURLY||(LA114_1>=BACKQUOTE && LA114_1<=STRING)||(LA114_1>=TRISTRINGPART && LA114_1<=STRINGPART)) ) { + alt114=1; + } + + + } + + + switch (alt114) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:41: COMMA subscript + { + match(input,COMMA,FOLLOW_COMMA_in_subscriptlist4234); if (state.failed) return ; + pushFollow(FOLLOW_subscript_in_subscriptlist4236); + subscript(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop114; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:59: ( COMMA )? + int alt115=2; + int LA115_0 = input.LA(1); + + if ( (LA115_0==COMMA) ) { + alt115=1; + } + switch (alt115) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:779:60: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_subscriptlist4241); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "subscriptlist" + + + // $ANTLR start "subscript" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:783:1: subscript : ( DOT DOT DOT | ( test COLON )=> test ( COLON ( test )? ( sliceop )? )? | ( COLON )=> COLON ( test )? ( sliceop )? | test ); + public final void subscript() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:784:5: ( DOT DOT DOT | ( test COLON )=> test ( COLON ( test )? ( sliceop )? )? | ( COLON )=> COLON ( test )? ( sliceop )? | test ) + int alt121=4; + alt121 = dfa121.predict(input); + switch (alt121) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:784:7: DOT DOT DOT + { + match(input,DOT,FOLLOW_DOT_in_subscript4261); if (state.failed) return ; + match(input,DOT,FOLLOW_DOT_in_subscript4263); if (state.failed) return ; + match(input,DOT,FOLLOW_DOT_in_subscript4265); if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:785:7: ( test COLON )=> test ( COLON ( test )? ( sliceop )? )? + { + pushFollow(FOLLOW_test_in_subscript4284); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:12: ( COLON ( test )? ( sliceop )? )? + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==COLON) ) { + alt118=1; + } + switch (alt118) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:13: COLON ( test )? ( sliceop )? + { + match(input,COLON,FOLLOW_COLON_in_subscript4287); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:19: ( test )? + int alt116=2; + int LA116_0 = input.LA(1); + + if ( (LA116_0==TRAILBACKSLASH||LA116_0==NAME||(LA116_0>=LAMBDA && LA116_0<=NOT)||LA116_0==LPAREN||(LA116_0>=PLUS && LA116_0<=MINUS)||(LA116_0>=TILDE && LA116_0<=LBRACK)||LA116_0==LCURLY||(LA116_0>=BACKQUOTE && LA116_0<=STRING)||(LA116_0>=TRISTRINGPART && LA116_0<=STRINGPART)) ) { + alt116=1; + } + switch (alt116) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:20: test + { + pushFollow(FOLLOW_test_in_subscript4290); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:27: ( sliceop )? + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==COLON) ) { + alt117=1; + } + switch (alt117) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:786:28: sliceop + { + pushFollow(FOLLOW_sliceop_in_subscript4295); + sliceop(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:787:7: ( COLON )=> COLON ( test )? ( sliceop )? + { + match(input,COLON,FOLLOW_COLON_in_subscript4316); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:788:13: ( test )? + int alt119=2; + int LA119_0 = input.LA(1); + + if ( (LA119_0==TRAILBACKSLASH||LA119_0==NAME||(LA119_0>=LAMBDA && LA119_0<=NOT)||LA119_0==LPAREN||(LA119_0>=PLUS && LA119_0<=MINUS)||(LA119_0>=TILDE && LA119_0<=LBRACK)||LA119_0==LCURLY||(LA119_0>=BACKQUOTE && LA119_0<=STRING)||(LA119_0>=TRISTRINGPART && LA119_0<=STRINGPART)) ) { + alt119=1; + } + switch (alt119) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:788:14: test + { + pushFollow(FOLLOW_test_in_subscript4319); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:788:21: ( sliceop )? + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==COLON) ) { + alt120=1; + } + switch (alt120) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:788:22: sliceop + { + pushFollow(FOLLOW_sliceop_in_subscript4324); + sliceop(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + case 4 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:789:7: test + { + pushFollow(FOLLOW_test_in_subscript4334); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "subscript" + + + // $ANTLR start "sliceop" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:793:1: sliceop : COLON ( test | ) ; + public final void sliceop() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:794:5: ( COLON ( test | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:794:7: COLON ( test | ) + { + match(input,COLON,FOLLOW_COLON_in_sliceop4352); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:795:6: ( test | ) + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==TRAILBACKSLASH||LA122_0==NAME||(LA122_0>=LAMBDA && LA122_0<=NOT)||LA122_0==LPAREN||(LA122_0>=PLUS && LA122_0<=MINUS)||(LA122_0>=TILDE && LA122_0<=LBRACK)||LA122_0==LCURLY||(LA122_0>=BACKQUOTE && LA122_0<=STRING)||(LA122_0>=TRISTRINGPART && LA122_0<=STRINGPART)) ) { + alt122=1; + } + else if ( (LA122_0==COMMA||LA122_0==RBRACK) ) { + alt122=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 122, 0, input); + + throw nvae; + } + switch (alt122) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:795:7: test + { + pushFollow(FOLLOW_test_in_sliceop4360); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:797:6: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "sliceop" + + + // $ANTLR start "exprlist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:801:1: exprlist : ( ( expr COMMA )=> expr ( options {k=2; } : COMMA expr )* ( COMMA )? | expr ); + public final void exprlist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:5: ( ( expr COMMA )=> expr ( options {k=2; } : COMMA expr )* ( COMMA )? | expr ) + int alt125=2; + alt125 = dfa125.predict(input); + switch (alt125) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:7: ( expr COMMA )=> expr ( options {k=2; } : COMMA expr )* ( COMMA )? + { + pushFollow(FOLLOW_expr_in_exprlist4400); + expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:28: ( options {k=2; } : COMMA expr )* + loop123: + do { + int alt123=2; + alt123 = dfa123.predict(input); + switch (alt123) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:45: COMMA expr + { + match(input,COMMA,FOLLOW_COMMA_in_exprlist4411); if (state.failed) return ; + pushFollow(FOLLOW_expr_in_exprlist4413); + expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop123; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:58: ( COMMA )? + int alt124=2; + int LA124_0 = input.LA(1); + + if ( (LA124_0==COMMA) ) { + alt124=1; + } + switch (alt124) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:59: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_exprlist4418); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:803:7: expr + { + pushFollow(FOLLOW_expr_in_exprlist4428); + expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "exprlist" + + + // $ANTLR start "del_list" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:808:1: del_list : expr ( options {k=2; } : COMMA expr )* ( COMMA )? ; + public final void del_list() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:5: ( expr ( options {k=2; } : COMMA expr )* ( COMMA )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:7: expr ( options {k=2; } : COMMA expr )* ( COMMA )? + { + pushFollow(FOLLOW_expr_in_del_list4447); + expr(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:12: ( options {k=2; } : COMMA expr )* + loop126: + do { + int alt126=2; + alt126 = dfa126.predict(input); + switch (alt126) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:29: COMMA expr + { + match(input,COMMA,FOLLOW_COMMA_in_del_list4458); if (state.failed) return ; + pushFollow(FOLLOW_expr_in_del_list4460); + expr(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop126; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:42: ( COMMA )? + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==COMMA) ) { + alt127=1; + } + switch (alt127) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:809:43: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_del_list4465); if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "del_list" + + + // $ANTLR start "testlist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:813:1: testlist : ( ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? | test ); + public final void testlist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:814:5: ( ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? | test ) + int alt130=2; + alt130 = dfa130.predict(input); + switch (alt130) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:814:7: ( test COMMA )=> test ( options {k=2; } : COMMA test )* ( COMMA )? + { + pushFollow(FOLLOW_test_in_testlist4496); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:815:12: ( options {k=2; } : COMMA test )* + loop128: + do { + int alt128=2; + alt128 = dfa128.predict(input); + switch (alt128) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:815:29: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_testlist4507); if (state.failed) return ; + pushFollow(FOLLOW_test_in_testlist4509); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop128; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:815:42: ( COMMA )? + int alt129=2; + int LA129_0 = input.LA(1); + + if ( (LA129_0==COMMA) ) { + alt129=1; + } + switch (alt129) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:815:43: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_testlist4514); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:816:7: test + { + pushFollow(FOLLOW_test_in_testlist4524); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "testlist" + + + // $ANTLR start "dictorsetmaker" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:821:1: dictorsetmaker : test ( ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) ( COMMA )? | comp_for ) ; + public final void dictorsetmaker() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:822:5: ( test ( ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) ( COMMA )? | comp_for ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:822:7: test ( ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) ( COMMA )? | comp_for ) + { + pushFollow(FOLLOW_test_in_dictorsetmaker4543); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:823:10: ( ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) ( COMMA )? | comp_for ) + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==COLON||LA136_0==COMMA||LA136_0==RCURLY) ) { + alt136=1; + } + else if ( (LA136_0==FOR) ) { + alt136=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 136, 0, input); + + throw nvae; + } + switch (alt136) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:824:14: ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) ( COMMA )? + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:824:14: ( COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) | ( COMMA test )* ) + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==COLON) ) { + alt134=1; + } + else if ( (LA134_0==COMMA||LA134_0==RCURLY) ) { + alt134=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 134, 0, input); + + throw nvae; + } + switch (alt134) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:824:15: COLON test ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) + { + match(input,COLON,FOLLOW_COLON_in_dictorsetmaker4570); if (state.failed) return ; + pushFollow(FOLLOW_test_in_dictorsetmaker4572); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:825:16: ( comp_for | ( options {k=2; } : COMMA test COLON test )* ) + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==FOR) ) { + alt132=1; + } + else if ( (LA132_0==COMMA||LA132_0==RCURLY) ) { + alt132=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 132, 0, input); + + throw nvae; + } + switch (alt132) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:825:18: comp_for + { + pushFollow(FOLLOW_comp_for_in_dictorsetmaker4591); + comp_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:826:18: ( options {k=2; } : COMMA test COLON test )* + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:826:18: ( options {k=2; } : COMMA test COLON test )* + loop131: + do { + int alt131=2; + alt131 = dfa131.predict(input); + switch (alt131) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:826:34: COMMA test COLON test + { + match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker4618); if (state.failed) return ; + pushFollow(FOLLOW_test_in_dictorsetmaker4620); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_dictorsetmaker4622); if (state.failed) return ; + pushFollow(FOLLOW_test_in_dictorsetmaker4624); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop131; + } + } while (true); + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:828:15: ( COMMA test )* + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:828:15: ( COMMA test )* + loop133: + do { + int alt133=2; + int LA133_0 = input.LA(1); + + if ( (LA133_0==COMMA) ) { + int LA133_1 = input.LA(2); + + if ( (LA133_1==TRAILBACKSLASH||LA133_1==NAME||(LA133_1>=LAMBDA && LA133_1<=NOT)||LA133_1==LPAREN||(LA133_1>=PLUS && LA133_1<=MINUS)||(LA133_1>=TILDE && LA133_1<=LBRACK)||LA133_1==LCURLY||(LA133_1>=BACKQUOTE && LA133_1<=STRING)||(LA133_1>=TRISTRINGPART && LA133_1<=STRINGPART)) ) { + alt133=1; + } + + + } + + + switch (alt133) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:828:16: COMMA test + { + match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker4660); if (state.failed) return ; + pushFollow(FOLLOW_test_in_dictorsetmaker4662); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop133; + } + } while (true); + + + } + break; + + } + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:830:14: ( COMMA )? + int alt135=2; + int LA135_0 = input.LA(1); + + if ( (LA135_0==COMMA) ) { + alt135=1; + } + switch (alt135) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:830:15: COMMA + { + match(input,COMMA,FOLLOW_COMMA_in_dictorsetmaker4695); if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:831:12: comp_for + { + pushFollow(FOLLOW_comp_for_in_dictorsetmaker4710); + comp_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "dictorsetmaker" + + + // $ANTLR start "classdef" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:836:1: classdef : ( decorators )? CLASS NAME ( LPAREN ( testlist )? RPAREN )? COLON suite ; + public final void classdef() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:5: ( ( decorators )? CLASS NAME ( LPAREN ( testlist )? RPAREN )? COLON suite ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:7: ( decorators )? CLASS NAME ( LPAREN ( testlist )? RPAREN )? COLON suite + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:7: ( decorators )? + int alt137=2; + int LA137_0 = input.LA(1); + + if ( (LA137_0==AT) ) { + alt137=1; + } + switch (alt137) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:7: decorators + { + pushFollow(FOLLOW_decorators_in_classdef4739); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,CLASS,FOLLOW_CLASS_in_classdef4742); if (state.failed) return ; + match(input,NAME,FOLLOW_NAME_in_classdef4744); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:30: ( LPAREN ( testlist )? RPAREN )? + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==LPAREN) ) { + alt139=1; + } + switch (alt139) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:31: LPAREN ( testlist )? RPAREN + { + match(input,LPAREN,FOLLOW_LPAREN_in_classdef4747); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:38: ( testlist )? + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==TRAILBACKSLASH||LA138_0==NAME||(LA138_0>=LAMBDA && LA138_0<=NOT)||LA138_0==LPAREN||(LA138_0>=PLUS && LA138_0<=MINUS)||(LA138_0>=TILDE && LA138_0<=LBRACK)||LA138_0==LCURLY||(LA138_0>=BACKQUOTE && LA138_0<=STRING)||(LA138_0>=TRISTRINGPART && LA138_0<=STRINGPART)) ) { + alt138=1; + } + switch (alt138) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:837:38: testlist + { + pushFollow(FOLLOW_testlist_in_classdef4749); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,RPAREN,FOLLOW_RPAREN_in_classdef4752); if (state.failed) return ; + + } + break; + + } + + match(input,COLON,FOLLOW_COLON_in_classdef4756); if (state.failed) return ; + pushFollow(FOLLOW_suite_in_classdef4758); + suite(); + + state._fsp--; + if (state.failed) return ; + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "classdef" + + + // $ANTLR start "arglist" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:843:1: arglist : ( argument ( COMMA argument )* ( COMMA ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? )? | STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test ); + public final void arglist() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:844:5: ( argument ( COMMA argument )* ( COMMA ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? )? | STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test ) + int alt147=3; + switch ( input.LA(1) ) { + case TRAILBACKSLASH: + case NAME: + case LAMBDA: + case NOT: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case LBRACK: + case LCURLY: + case BACKQUOTE: + case INT: + case LONGINT: + case FLOAT: + case COMPLEX: + case STRING: + case TRISTRINGPART: + case STRINGPART: + { + alt147=1; + } + break; + case STAR: + { + alt147=2; + } + break; + case DOUBLESTAR: + { + alt147=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 147, 0, input); + + throw nvae; + } + + switch (alt147) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:844:7: argument ( COMMA argument )* ( COMMA ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? )? + { + pushFollow(FOLLOW_argument_in_arglist4778); + argument(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:844:16: ( COMMA argument )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==COMMA) ) { + int LA140_1 = input.LA(2); + + if ( (LA140_1==TRAILBACKSLASH||LA140_1==NAME||(LA140_1>=LAMBDA && LA140_1<=NOT)||LA140_1==LPAREN||(LA140_1>=PLUS && LA140_1<=MINUS)||(LA140_1>=TILDE && LA140_1<=LBRACK)||LA140_1==LCURLY||(LA140_1>=BACKQUOTE && LA140_1<=STRING)||(LA140_1>=TRISTRINGPART && LA140_1<=STRINGPART)) ) { + alt140=1; + } + + + } + + + switch (alt140) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:844:17: COMMA argument + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4781); if (state.failed) return ; + pushFollow(FOLLOW_argument_in_arglist4783); + argument(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop140; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:845:11: ( COMMA ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? )? + int alt144=2; + int LA144_0 = input.LA(1); + + if ( (LA144_0==COMMA) ) { + alt144=1; + } + switch (alt144) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:845:12: COMMA ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4798); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:15: ( STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? | DOUBLESTAR test )? + int alt143=3; + int LA143_0 = input.LA(1); + + if ( (LA143_0==STAR) ) { + alt143=1; + } + else if ( (LA143_0==DOUBLESTAR) ) { + alt143=2; + } + switch (alt143) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:17: STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? + { + match(input,STAR,FOLLOW_STAR_in_arglist4816); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4818); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:27: ( COMMA argument )* + loop141: + do { + int alt141=2; + int LA141_0 = input.LA(1); + + if ( (LA141_0==COMMA) ) { + int LA141_1 = input.LA(2); + + if ( (LA141_1==TRAILBACKSLASH||LA141_1==NAME||(LA141_1>=LAMBDA && LA141_1<=NOT)||LA141_1==LPAREN||(LA141_1>=PLUS && LA141_1<=MINUS)||(LA141_1>=TILDE && LA141_1<=LBRACK)||LA141_1==LCURLY||(LA141_1>=BACKQUOTE && LA141_1<=STRING)||(LA141_1>=TRISTRINGPART && LA141_1<=STRINGPART)) ) { + alt141=1; + } + + + } + + + switch (alt141) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:28: COMMA argument + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4821); if (state.failed) return ; + pushFollow(FOLLOW_argument_in_arglist4823); + argument(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop141; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:45: ( COMMA DOUBLESTAR test )? + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==COMMA) ) { + alt142=1; + } + switch (alt142) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:846:46: COMMA DOUBLESTAR test + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4828); if (state.failed) return ; + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist4830); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4832); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:847:17: DOUBLESTAR test + { + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist4852); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4854); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:850:7: STAR test ( COMMA argument )* ( COMMA DOUBLESTAR test )? + { + match(input,STAR,FOLLOW_STAR_in_arglist4892); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4894); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:850:17: ( COMMA argument )* + loop145: + do { + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==COMMA) ) { + int LA145_1 = input.LA(2); + + if ( (LA145_1==TRAILBACKSLASH||LA145_1==NAME||(LA145_1>=LAMBDA && LA145_1<=NOT)||LA145_1==LPAREN||(LA145_1>=PLUS && LA145_1<=MINUS)||(LA145_1>=TILDE && LA145_1<=LBRACK)||LA145_1==LCURLY||(LA145_1>=BACKQUOTE && LA145_1<=STRING)||(LA145_1>=TRISTRINGPART && LA145_1<=STRINGPART)) ) { + alt145=1; + } + + + } + + + switch (alt145) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:850:18: COMMA argument + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4897); if (state.failed) return ; + pushFollow(FOLLOW_argument_in_arglist4899); + argument(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop145; + } + } while (true); + + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:850:35: ( COMMA DOUBLESTAR test )? + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==COMMA) ) { + alt146=1; + } + switch (alt146) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:850:36: COMMA DOUBLESTAR test + { + match(input,COMMA,FOLLOW_COMMA_in_arglist4904); if (state.failed) return ; + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist4906); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4908); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:851:7: DOUBLESTAR test + { + match(input,DOUBLESTAR,FOLLOW_DOUBLESTAR_in_arglist4918); if (state.failed) return ; + pushFollow(FOLLOW_test_in_arglist4920); + test(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "arglist" + + + // $ANTLR start "argument" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:855:1: argument : test ( ( ASSIGN test ) | comp_for | ) ; + public final void argument() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:856:5: ( test ( ( ASSIGN test ) | comp_for | ) ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:856:7: test ( ( ASSIGN test ) | comp_for | ) + { + pushFollow(FOLLOW_test_in_argument4938); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:857:9: ( ( ASSIGN test ) | comp_for | ) + int alt148=3; + switch ( input.LA(1) ) { + case ASSIGN: + { + alt148=1; + } + break; + case FOR: + { + alt148=2; + } + break; + case RPAREN: + case COMMA: + { + alt148=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 148, 0, input); + + throw nvae; + } + + switch (alt148) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:857:10: ( ASSIGN test ) + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:857:10: ( ASSIGN test ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:857:11: ASSIGN test + { + match(input,ASSIGN,FOLLOW_ASSIGN_in_argument4950); if (state.failed) return ; + pushFollow(FOLLOW_test_in_argument4952); + test(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:858:11: comp_for + { + pushFollow(FOLLOW_comp_for_in_argument4965); + comp_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 3 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:860:9: + { + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "argument" + + + // $ANTLR start "list_iter" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:864:1: list_iter : ( list_for | list_if ); + public final void list_iter() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:865:5: ( list_for | list_if ) + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==FOR) ) { + alt149=1; + } + else if ( (LA149_0==IF) ) { + alt149=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 149, 0, input); + + throw nvae; + } + switch (alt149) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:865:7: list_for + { + pushFollow(FOLLOW_list_for_in_list_iter5003); + list_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:866:7: list_if + { + pushFollow(FOLLOW_list_if_in_list_iter5011); + list_if(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "list_iter" + + + // $ANTLR start "list_for" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:870:1: list_for : FOR exprlist IN testlist ( list_iter )? ; + public final void list_for() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:871:5: ( FOR exprlist IN testlist ( list_iter )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:871:7: FOR exprlist IN testlist ( list_iter )? + { + match(input,FOR,FOLLOW_FOR_in_list_for5029); if (state.failed) return ; + pushFollow(FOLLOW_exprlist_in_list_for5031); + exprlist(); + + state._fsp--; + if (state.failed) return ; + match(input,IN,FOLLOW_IN_in_list_for5033); if (state.failed) return ; + pushFollow(FOLLOW_testlist_in_list_for5035); + testlist(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:871:32: ( list_iter )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==FOR||LA150_0==IF) ) { + alt150=1; + } + switch (alt150) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:871:33: list_iter + { + pushFollow(FOLLOW_list_iter_in_list_for5038); + list_iter(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "list_for" + + + // $ANTLR start "list_if" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:875:1: list_if : IF test ( list_iter )? ; + public final void list_if() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:876:5: ( IF test ( list_iter )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:876:7: IF test ( list_iter )? + { + match(input,IF,FOLLOW_IF_in_list_if5058); if (state.failed) return ; + pushFollow(FOLLOW_test_in_list_if5060); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:876:15: ( list_iter )? + int alt151=2; + int LA151_0 = input.LA(1); + + if ( (LA151_0==FOR||LA151_0==IF) ) { + alt151=1; + } + switch (alt151) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:876:16: list_iter + { + pushFollow(FOLLOW_list_iter_in_list_if5063); + list_iter(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "list_if" + + + // $ANTLR start "comp_iter" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:880:1: comp_iter : ( comp_for | comp_if ); + public final void comp_iter() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:881:5: ( comp_for | comp_if ) + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==FOR) ) { + alt152=1; + } + else if ( (LA152_0==IF) ) { + alt152=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 152, 0, input); + + throw nvae; + } + switch (alt152) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:881:7: comp_for + { + pushFollow(FOLLOW_comp_for_in_comp_iter5083); + comp_for(); + + state._fsp--; + if (state.failed) return ; + + } + break; + case 2 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:882:7: comp_if + { + pushFollow(FOLLOW_comp_if_in_comp_iter5091); + comp_if(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "comp_iter" + + + // $ANTLR start "comp_for" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:886:1: comp_for : FOR exprlist IN or_test ( comp_iter )? ; + public final void comp_for() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:887:5: ( FOR exprlist IN or_test ( comp_iter )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:887:7: FOR exprlist IN or_test ( comp_iter )? + { + match(input,FOR,FOLLOW_FOR_in_comp_for5109); if (state.failed) return ; + pushFollow(FOLLOW_exprlist_in_comp_for5111); + exprlist(); + + state._fsp--; + if (state.failed) return ; + match(input,IN,FOLLOW_IN_in_comp_for5113); if (state.failed) return ; + pushFollow(FOLLOW_or_test_in_comp_for5115); + or_test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:887:31: ( comp_iter )? + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==FOR||LA153_0==IF) ) { + alt153=1; + } + switch (alt153) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:887:31: comp_iter + { + pushFollow(FOLLOW_comp_iter_in_comp_for5117); + comp_iter(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "comp_for" + + + // $ANTLR start "comp_if" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:891:1: comp_if : IF test ( comp_iter )? ; + public final void comp_if() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:892:5: ( IF test ( comp_iter )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:892:7: IF test ( comp_iter )? + { + match(input,IF,FOLLOW_IF_in_comp_if5136); if (state.failed) return ; + pushFollow(FOLLOW_test_in_comp_if5138); + test(); + + state._fsp--; + if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:892:15: ( comp_iter )? + int alt154=2; + int LA154_0 = input.LA(1); + + if ( (LA154_0==FOR||LA154_0==IF) ) { + alt154=1; + } + switch (alt154) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:892:15: comp_iter + { + pushFollow(FOLLOW_comp_iter_in_comp_if5140); + comp_iter(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "comp_if" + + + // $ANTLR start "yield_expr" + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:896:1: yield_expr : YIELD ( testlist )? ; + public final void yield_expr() throws RecognitionException { + try { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:897:5: ( YIELD ( testlist )? ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:897:7: YIELD ( testlist )? + { + match(input,YIELD,FOLLOW_YIELD_in_yield_expr5159); if (state.failed) return ; + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:897:13: ( testlist )? + int alt155=2; + int LA155_0 = input.LA(1); + + if ( (LA155_0==TRAILBACKSLASH||LA155_0==NAME||(LA155_0>=LAMBDA && LA155_0<=NOT)||LA155_0==LPAREN||(LA155_0>=PLUS && LA155_0<=MINUS)||(LA155_0>=TILDE && LA155_0<=LBRACK)||LA155_0==LCURLY||(LA155_0>=BACKQUOTE && LA155_0<=STRING)||(LA155_0>=TRISTRINGPART && LA155_0<=STRINGPART)) ) { + alt155=1; + } + switch (alt155) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:897:13: testlist + { + pushFollow(FOLLOW_testlist_in_yield_expr5161); + testlist(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + + } + + } + + catch (RecognitionException e) { + throw e; + } + finally { + } + return ; + } + // $ANTLR end "yield_expr" + + // $ANTLR start synpred1_PythonPartial + public final void synpred1_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:289:7: ( LPAREN fpdef COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:289:8: LPAREN fpdef COMMA + { + match(input,LPAREN,FOLLOW_LPAREN_in_synpred1_PythonPartial807); if (state.failed) return ; + pushFollow(FOLLOW_fpdef_in_synpred1_PythonPartial809); + fpdef(); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred1_PythonPartial811); if (state.failed) return ; + + } + } + // $ANTLR end synpred1_PythonPartial + + // $ANTLR start synpred2_PythonPartial + public final void synpred2_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:8: ( testlist augassign ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:326:9: testlist augassign + { + pushFollow(FOLLOW_testlist_in_synpred2_PythonPartial1107); + testlist(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_augassign_in_synpred2_PythonPartial1109); + augassign(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred2_PythonPartial + + // $ANTLR start synpred3_PythonPartial + public final void synpred3_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:332:7: ( testlist ASSIGN ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:332:8: testlist ASSIGN + { + pushFollow(FOLLOW_testlist_in_synpred3_PythonPartial1187); + testlist(); + + state._fsp--; + if (state.failed) return ; + match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred3_PythonPartial1189); if (state.failed) return ; + + } + } + // $ANTLR end synpred3_PythonPartial + + // $ANTLR start synpred4_PythonPartial + public final void synpred4_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:372:7: ( test COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:372:8: test COMMA + { + pushFollow(FOLLOW_test_in_synpred4_PythonPartial1472); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred4_PythonPartial1474); if (state.failed) return ; + + } + } + // $ANTLR end synpred4_PythonPartial + + // $ANTLR start synpred5_PythonPartial + public final void synpred5_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:495:7: ( ( decorators )? DEF ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:495:8: ( decorators )? DEF + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:495:8: ( decorators )? + int alt156=2; + int LA156_0 = input.LA(1); + + if ( (LA156_0==AT) ) { + alt156=1; + } + switch (alt156) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:495:8: decorators + { + pushFollow(FOLLOW_decorators_in_synpred5_PythonPartial2157); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,DEF,FOLLOW_DEF_in_synpred5_PythonPartial2160); if (state.failed) return ; + + } + } + // $ANTLR end synpred5_PythonPartial + + // $ANTLR start synpred6_PythonPartial + public final void synpred6_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:496:7: ( ( decorators )? CLASS ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:496:8: ( decorators )? CLASS + { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:496:8: ( decorators )? + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==AT) ) { + alt157=1; + } + switch (alt157) { + case 1 : + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:496:8: decorators + { + pushFollow(FOLLOW_decorators_in_synpred6_PythonPartial2174); + decorators(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + match(input,CLASS,FOLLOW_CLASS_in_synpred6_PythonPartial2177); if (state.failed) return ; + + } + } + // $ANTLR end synpred6_PythonPartial + + // $ANTLR start synpred7_PythonPartial + public final void synpred7_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:571:9: ( IF or_test ORELSE ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:571:10: IF or_test ORELSE + { + match(input,IF,FOLLOW_IF_in_synpred7_PythonPartial2752); if (state.failed) return ; + pushFollow(FOLLOW_or_test_in_synpred7_PythonPartial2754); + or_test(); + + state._fsp--; + if (state.failed) return ; + match(input,ORELSE,FOLLOW_ORELSE_in_synpred7_PythonPartial2756); if (state.failed) return ; + + } + } + // $ANTLR end synpred7_PythonPartial + + // $ANTLR start synpred8_PythonPartial + public final void synpred8_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:785:7: ( test COLON ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:785:8: test COLON + { + pushFollow(FOLLOW_test_in_synpred8_PythonPartial4274); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COLON,FOLLOW_COLON_in_synpred8_PythonPartial4276); if (state.failed) return ; + + } + } + // $ANTLR end synpred8_PythonPartial + + // $ANTLR start synpred9_PythonPartial + public final void synpred9_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:787:7: ( COLON ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:787:8: COLON + { + match(input,COLON,FOLLOW_COLON_in_synpred9_PythonPartial4308); if (state.failed) return ; + + } + } + // $ANTLR end synpred9_PythonPartial + + // $ANTLR start synpred10_PythonPartial + public final void synpred10_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:7: ( expr COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:802:8: expr COMMA + { + pushFollow(FOLLOW_expr_in_synpred10_PythonPartial4393); + expr(); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred10_PythonPartial4395); if (state.failed) return ; + + } + } + // $ANTLR end synpred10_PythonPartial + + // $ANTLR start synpred11_PythonPartial + public final void synpred11_PythonPartial_fragment() throws RecognitionException { + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:814:7: ( test COMMA ) + // /Users/orion.moore/apps/code/jython/grammar/PythonPartial.g:814:8: test COMMA + { + pushFollow(FOLLOW_test_in_synpred11_PythonPartial4486); + test(); + + state._fsp--; + if (state.failed) return ; + match(input,COMMA,FOLLOW_COMMA_in_synpred11_PythonPartial4488); if (state.failed) return ; + + } + } + // $ANTLR end synpred11_PythonPartial + + // Delegated rules + + public final boolean synpred3_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred6_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred6_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred10_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred10_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred9_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred9_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred5_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred5_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred1_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred11_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred11_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred2_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred8_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred8_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_PythonPartial() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_PythonPartial_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA27 dfa27 = new DFA27(this); + protected DFA32 dfa32 = new DFA32(this); + protected DFA36 dfa36 = new DFA36(this); + protected DFA34 dfa34 = new DFA34(this); + protected DFA45 dfa45 = new DFA45(this); + protected DFA57 dfa57 = new DFA57(this); + protected DFA75 dfa75 = new DFA75(this); + protected DFA84 dfa84 = new DFA84(this); + protected DFA108 dfa108 = new DFA108(this); + protected DFA121 dfa121 = new DFA121(this); + protected DFA125 dfa125 = new DFA125(this); + protected DFA123 dfa123 = new DFA123(this); + protected DFA126 dfa126 = new DFA126(this); + protected DFA130 dfa130 = new DFA130(this); + protected DFA128 dfa128 = new DFA128(this); + protected DFA131 dfa131 = new DFA131(this); + static final String DFA27_eotS = + "\12\uffff"; + static final String DFA27_eofS = + "\12\uffff"; + static final String DFA27_minS = + "\1\6\11\uffff"; + static final String DFA27_maxS = + "\1\144\11\uffff"; + static final String DFA27_acceptS = + "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11"; + static final String DFA27_specialS = + "\12\uffff}>"; + static final String[] DFA27_transitionS = { + "\1\1\2\uffff\1\1\1\uffff\1\2\2\uffff\1\11\1\5\1\uffff\1\5\1"+ + "\uffff\1\3\2\uffff\1\10\1\uffff\1\6\1\uffff\1\7\1\uffff\1\6"+ + "\2\uffff\2\1\2\uffff\1\4\2\5\3\uffff\1\5\1\uffff\1\1\37\uffff"+ + "\2\1\3\uffff\2\1\1\uffff\1\1\1\uffff\6\1\10\uffff\2\1", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS); + static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS); + static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS); + static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS); + static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS); + static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS); + static final short[][] DFA27_transition; + + static { + int numStates = DFA27_transitionS.length; + DFA27_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA32_transitionS = { + "\1\21\2\uffff\1\11\25\uffff\1\22\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\12\1\13\1"+ + "\14\1\15\1\16\10\uffff\1\17\1\20", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "" + }; + + static final short[] DFA32_eot = DFA.unpackEncodedString(DFA32_eotS); + static final short[] DFA32_eof = DFA.unpackEncodedString(DFA32_eofS); + static final char[] DFA32_min = DFA.unpackEncodedStringToUnsignedChars(DFA32_minS); + static final char[] DFA32_max = DFA.unpackEncodedStringToUnsignedChars(DFA32_maxS); + static final short[] DFA32_accept = DFA.unpackEncodedString(DFA32_acceptS); + static final short[] DFA32_special = DFA.unpackEncodedString(DFA32_specialS); + static final short[][] DFA32_transition; + + static { + int numStates = DFA32_transitionS.length; + DFA32_transition = new short[numStates][]; + for (int i=0; i testlist ( ( augassign yield_expr ) | ( augassign testlist ) ) | ( testlist ASSIGN )=> testlist ( | ( ( ASSIGN testlist )+ ) | ( ( ASSIGN yield_expr )+ ) ) | testlist )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA32_1 = input.LA(1); + + + int index32_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA32_2 = input.LA(1); + + + int index32_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA32_3 = input.LA(1); + + + int index32_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA32_4 = input.LA(1); + + + int index32_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA32_5 = input.LA(1); + + + int index32_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA32_6 = input.LA(1); + + + int index32_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA32_7 = input.LA(1); + + + int index32_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA32_8 = input.LA(1); + + + int index32_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA32_9 = input.LA(1); + + + int index32_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA32_10 = input.LA(1); + + + int index32_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA32_11 = input.LA(1); + + + int index32_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA32_12 = input.LA(1); + + + int index32_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA32_13 = input.LA(1); + + + int index32_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA32_14 = input.LA(1); + + + int index32_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA32_15 = input.LA(1); + + + int index32_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA32_16 = input.LA(1); + + + int index32_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA32_17 = input.LA(1); + + + int index32_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA32_18 = input.LA(1); + + + int index32_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_PythonPartial()) ) {s = 19;} + + else if ( (synpred3_PythonPartial()) ) {s = 20;} + + else if ( (true) ) {s = 21;} + + + input.seek(index32_18); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 32, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA36_eotS = + "\25\uffff"; + static final String DFA36_eofS = + "\25\uffff"; + static final String DFA36_minS = + "\1\6\22\0\2\uffff"; + static final String DFA36_maxS = + "\1\144\22\0\2\uffff"; + static final String DFA36_acceptS = + "\23\uffff\1\1\1\2"; + static final String DFA36_specialS = + "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ + "\1\15\1\16\1\17\1\20\1\21\2\uffff}>"; + static final String[] DFA36_transitionS = { + "\1\21\2\uffff\1\11\25\uffff\1\22\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\12\1\13\1"+ + "\14\1\15\1\16\10\uffff\1\17\1\20", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS); + static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS); + static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS); + static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS); + static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS); + static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS); + static final short[][] DFA36_transition; + + static { + int numStates = DFA36_transitionS.length; + DFA36_transition = new short[numStates][]; + for (int i=0; i test ( options {k=2; } : COMMA test )* ( COMMA )? | test );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA36_1 = input.LA(1); + + + int index36_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA36_2 = input.LA(1); + + + int index36_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA36_3 = input.LA(1); + + + int index36_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA36_4 = input.LA(1); + + + int index36_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA36_5 = input.LA(1); + + + int index36_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA36_6 = input.LA(1); + + + int index36_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA36_7 = input.LA(1); + + + int index36_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA36_8 = input.LA(1); + + + int index36_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA36_9 = input.LA(1); + + + int index36_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA36_10 = input.LA(1); + + + int index36_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA36_11 = input.LA(1); + + + int index36_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA36_12 = input.LA(1); + + + int index36_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA36_13 = input.LA(1); + + + int index36_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA36_14 = input.LA(1); + + + int index36_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA36_15 = input.LA(1); + + + int index36_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA36_16 = input.LA(1); + + + int index36_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA36_17 = input.LA(1); + + + int index36_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA36_18 = input.LA(1); + + + int index36_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index36_18); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 36, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA34_eotS = + "\30\uffff"; + static final String DFA34_eofS = + "\2\2\26\uffff"; + static final String DFA34_minS = + "\1\7\1\6\26\uffff"; + static final String DFA34_maxS = + "\1\62\1\144\26\uffff"; + static final String DFA34_acceptS = + "\2\uffff\1\2\1\uffff\1\1\23\uffff"; + static final String DFA34_specialS = + "\30\uffff}>"; + static final String[] DFA34_transitionS = { + "\1\2\47\uffff\1\1\2\uffff\1\2", + "\1\4\1\2\1\uffff\1\4\25\uffff\2\4\12\uffff\1\4\6\uffff\1\2"+ + "\30\uffff\2\4\3\uffff\2\4\1\uffff\1\4\1\uffff\6\4\10\uffff\2"+ + "\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA34_eot = DFA.unpackEncodedString(DFA34_eotS); + static final short[] DFA34_eof = DFA.unpackEncodedString(DFA34_eofS); + static final char[] DFA34_min = DFA.unpackEncodedStringToUnsignedChars(DFA34_minS); + static final char[] DFA34_max = DFA.unpackEncodedStringToUnsignedChars(DFA34_maxS); + static final short[] DFA34_accept = DFA.unpackEncodedString(DFA34_acceptS); + static final short[] DFA34_special = DFA.unpackEncodedString(DFA34_specialS); + static final short[][] DFA34_transition; + + static { + int numStates = DFA34_transitionS.length; + DFA34_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA45_transitionS = { + "\1\2\1\1", + "\1\2\1\1\21\uffff\1\3", + "", + "" + }; + + static final short[] DFA45_eot = DFA.unpackEncodedString(DFA45_eotS); + static final short[] DFA45_eof = DFA.unpackEncodedString(DFA45_eofS); + static final char[] DFA45_min = DFA.unpackEncodedStringToUnsignedChars(DFA45_minS); + static final char[] DFA45_max = DFA.unpackEncodedStringToUnsignedChars(DFA45_maxS); + static final short[] DFA45_accept = DFA.unpackEncodedString(DFA45_acceptS); + static final short[] DFA45_special = DFA.unpackEncodedString(DFA45_specialS); + static final short[][] DFA45_transition; + + static { + int numStates = DFA45_transitionS.length; + DFA45_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA57_transitionS = { + "\1\10\1\uffff\1\7\6\uffff\1\3\1\uffff\1\1\12\uffff\1\4\1\2\1"+ + "\5\1\uffff\1\6", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "" + }; + + static final short[] DFA57_eot = DFA.unpackEncodedString(DFA57_eotS); + static final short[] DFA57_eof = DFA.unpackEncodedString(DFA57_eofS); + static final char[] DFA57_min = DFA.unpackEncodedStringToUnsignedChars(DFA57_minS); + static final char[] DFA57_max = DFA.unpackEncodedStringToUnsignedChars(DFA57_maxS); + static final short[] DFA57_accept = DFA.unpackEncodedString(DFA57_acceptS); + static final short[] DFA57_special = DFA.unpackEncodedString(DFA57_specialS); + static final short[][] DFA57_transition; + + static { + int numStates = DFA57_transitionS.length; + DFA57_transition = new short[numStates][]; + for (int i=0; i funcdef | ( ( decorators )? CLASS )=> classdef | decorators );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA57_0 = input.LA(1); + + + int index57_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA57_0==IF) ) {s = 1;} + + else if ( (LA57_0==WHILE) ) {s = 2;} + + else if ( (LA57_0==FOR) ) {s = 3;} + + else if ( (LA57_0==TRY) ) {s = 4;} + + else if ( (LA57_0==WITH) ) {s = 5;} + + else if ( (LA57_0==AT) ) {s = 6;} + + else if ( (LA57_0==DEF) && (synpred5_PythonPartial())) {s = 7;} + + else if ( (LA57_0==CLASS) && (synpred6_PythonPartial())) {s = 8;} + + + input.seek(index57_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA57_6 = input.LA(1); + + + int index57_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred5_PythonPartial()) ) {s = 7;} + + else if ( (synpred6_PythonPartial()) ) {s = 8;} + + else if ( (true) ) {s = 9;} + + + input.seek(index57_6); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 57, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA75_eotS = + "\20\uffff"; + static final String DFA75_eofS = + "\1\2\17\uffff"; + static final String DFA75_minS = + "\1\7\1\0\16\uffff"; + static final String DFA75_maxS = + "\1\125\1\0\16\uffff"; + static final String DFA75_acceptS = + "\2\uffff\1\2\14\uffff\1\1"; + static final String DFA75_specialS = + "\1\uffff\1\0\16\uffff}>"; + static final String[] DFA75_transitionS = { + "\1\2\5\uffff\1\2\13\uffff\1\2\1\uffff\1\1\20\uffff\4\2\2\uffff"+ + "\15\2\23\uffff\1\2\1\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA75_eot = DFA.unpackEncodedString(DFA75_eotS); + static final short[] DFA75_eof = DFA.unpackEncodedString(DFA75_eofS); + static final char[] DFA75_min = DFA.unpackEncodedStringToUnsignedChars(DFA75_minS); + static final char[] DFA75_max = DFA.unpackEncodedStringToUnsignedChars(DFA75_maxS); + static final short[] DFA75_accept = DFA.unpackEncodedString(DFA75_acceptS); + static final short[] DFA75_special = DFA.unpackEncodedString(DFA75_specialS); + static final short[][] DFA75_transition; + + static { + int numStates = DFA75_transitionS.length; + DFA75_transition = new short[numStates][]; + for (int i=0; i IF or_test ORELSE test | )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA75_1 = input.LA(1); + + + int index75_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred7_PythonPartial()) ) {s = 15;} + + else if ( (true) ) {s = 2;} + + + input.seek(index75_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 75, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA84_eotS = + "\15\uffff"; + static final String DFA84_eofS = + "\15\uffff"; + static final String DFA84_minS = + "\1\35\11\uffff\1\6\2\uffff"; + static final String DFA84_maxS = + "\1\106\11\uffff\1\144\2\uffff"; + static final String DFA84_acceptS = + "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\uffff\1\13\1\12"; + static final String DFA84_specialS = + "\15\uffff}>"; + static final String[] DFA84_transitionS = { + "\1\10\1\12\1\uffff\1\11\37\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\14\2\uffff\1\14\26\uffff\1\13\12\uffff\1\14\37\uffff\2\14"+ + "\3\uffff\2\14\1\uffff\1\14\1\uffff\6\14\10\uffff\2\14", + "", + "" + }; + + static final short[] DFA84_eot = DFA.unpackEncodedString(DFA84_eotS); + static final short[] DFA84_eof = DFA.unpackEncodedString(DFA84_eofS); + static final char[] DFA84_min = DFA.unpackEncodedStringToUnsignedChars(DFA84_minS); + static final char[] DFA84_max = DFA.unpackEncodedStringToUnsignedChars(DFA84_maxS); + static final short[] DFA84_accept = DFA.unpackEncodedString(DFA84_acceptS); + static final short[] DFA84_special = DFA.unpackEncodedString(DFA84_specialS); + static final short[][] DFA84_transition; + + static { + int numStates = DFA84_transitionS.length; + DFA84_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA108_transitionS = { + "\1\2\2\uffff\1\1", + "\1\4\2\uffff\1\4\25\uffff\2\4\12\uffff\1\4\1\2\36\uffff\2\4"+ + "\3\uffff\2\4\1\uffff\1\4\1\uffff\6\4\10\uffff\2\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA108_eot = DFA.unpackEncodedString(DFA108_eotS); + static final short[] DFA108_eof = DFA.unpackEncodedString(DFA108_eofS); + static final char[] DFA108_min = DFA.unpackEncodedStringToUnsignedChars(DFA108_minS); + static final char[] DFA108_max = DFA.unpackEncodedStringToUnsignedChars(DFA108_maxS); + static final short[] DFA108_accept = DFA.unpackEncodedString(DFA108_acceptS); + static final short[] DFA108_special = DFA.unpackEncodedString(DFA108_specialS); + static final short[][] DFA108_transition; + + static { + int numStates = DFA108_transitionS.length; + DFA108_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA121_transitionS = { + "\1\22\2\uffff\1\12\1\1\24\uffff\1\23\1\2\12\uffff\1\6\1\uffff"+ + "\1\24\35\uffff\1\3\1\4\3\uffff\1\5\1\7\1\uffff\1\10\1\uffff"+ + "\1\11\1\13\1\14\1\15\1\16\1\17\10\uffff\1\20\1\21", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "" + }; + + static final short[] DFA121_eot = DFA.unpackEncodedString(DFA121_eotS); + static final short[] DFA121_eof = DFA.unpackEncodedString(DFA121_eofS); + static final char[] DFA121_min = DFA.unpackEncodedStringToUnsignedChars(DFA121_minS); + static final char[] DFA121_max = DFA.unpackEncodedStringToUnsignedChars(DFA121_maxS); + static final short[] DFA121_accept = DFA.unpackEncodedString(DFA121_acceptS); + static final short[] DFA121_special = DFA.unpackEncodedString(DFA121_specialS); + static final short[][] DFA121_transition; + + static { + int numStates = DFA121_transitionS.length; + DFA121_transition = new short[numStates][]; + for (int i=0; i test ( COLON ( test )? ( sliceop )? )? | ( COLON )=> COLON ( test )? ( sliceop )? | test );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA121_0 = input.LA(1); + + + int index121_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA121_0==DOT) ) {s = 1;} + + else if ( (LA121_0==NOT) ) {s = 2;} + + else if ( (LA121_0==PLUS) ) {s = 3;} + + else if ( (LA121_0==MINUS) ) {s = 4;} + + else if ( (LA121_0==TILDE) ) {s = 5;} + + else if ( (LA121_0==LPAREN) ) {s = 6;} + + else if ( (LA121_0==LBRACK) ) {s = 7;} + + else if ( (LA121_0==LCURLY) ) {s = 8;} + + else if ( (LA121_0==BACKQUOTE) ) {s = 9;} + + else if ( (LA121_0==NAME) ) {s = 10;} + + else if ( (LA121_0==INT) ) {s = 11;} + + else if ( (LA121_0==LONGINT) ) {s = 12;} + + else if ( (LA121_0==FLOAT) ) {s = 13;} + + else if ( (LA121_0==COMPLEX) ) {s = 14;} + + else if ( (LA121_0==STRING) ) {s = 15;} + + else if ( (LA121_0==TRISTRINGPART) ) {s = 16;} + + else if ( (LA121_0==STRINGPART) ) {s = 17;} + + else if ( (LA121_0==TRAILBACKSLASH) ) {s = 18;} + + else if ( (LA121_0==LAMBDA) ) {s = 19;} + + else if ( (LA121_0==COLON) && (synpred9_PythonPartial())) {s = 20;} + + + input.seek(index121_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA121_2 = input.LA(1); + + + int index121_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA121_3 = input.LA(1); + + + int index121_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA121_4 = input.LA(1); + + + int index121_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA121_5 = input.LA(1); + + + int index121_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA121_6 = input.LA(1); + + + int index121_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA121_7 = input.LA(1); + + + int index121_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA121_8 = input.LA(1); + + + int index121_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA121_9 = input.LA(1); + + + int index121_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA121_10 = input.LA(1); + + + int index121_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA121_11 = input.LA(1); + + + int index121_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA121_12 = input.LA(1); + + + int index121_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA121_13 = input.LA(1); + + + int index121_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA121_14 = input.LA(1); + + + int index121_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA121_15 = input.LA(1); + + + int index121_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA121_16 = input.LA(1); + + + int index121_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA121_17 = input.LA(1); + + + int index121_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA121_18 = input.LA(1); + + + int index121_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA121_19 = input.LA(1); + + + int index121_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred8_PythonPartial()) ) {s = 21;} + + else if ( (true) ) {s = 22;} + + + input.seek(index121_19); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 121, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA125_eotS = + "\23\uffff"; + static final String DFA125_eofS = + "\23\uffff"; + static final String DFA125_minS = + "\1\6\20\0\2\uffff"; + static final String DFA125_maxS = + "\1\144\20\0\2\uffff"; + static final String DFA125_acceptS = + "\21\uffff\1\1\1\2"; + static final String DFA125_specialS = + "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ + "\1\15\1\16\1\17\2\uffff}>"; + static final String[] DFA125_transitionS = { + "\1\20\2\uffff\1\10\41\uffff\1\4\37\uffff\1\1\1\2\3\uffff\1\3"+ + "\1\5\1\uffff\1\6\1\uffff\1\7\1\11\1\12\1\13\1\14\1\15\10\uffff"+ + "\1\16\1\17", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA125_eot = DFA.unpackEncodedString(DFA125_eotS); + static final short[] DFA125_eof = DFA.unpackEncodedString(DFA125_eofS); + static final char[] DFA125_min = DFA.unpackEncodedStringToUnsignedChars(DFA125_minS); + static final char[] DFA125_max = DFA.unpackEncodedStringToUnsignedChars(DFA125_maxS); + static final short[] DFA125_accept = DFA.unpackEncodedString(DFA125_acceptS); + static final short[] DFA125_special = DFA.unpackEncodedString(DFA125_specialS); + static final short[][] DFA125_transition; + + static { + int numStates = DFA125_transitionS.length; + DFA125_transition = new short[numStates][]; + for (int i=0; i expr ( options {k=2; } : COMMA expr )* ( COMMA )? | expr );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA125_1 = input.LA(1); + + + int index125_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA125_2 = input.LA(1); + + + int index125_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA125_3 = input.LA(1); + + + int index125_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA125_4 = input.LA(1); + + + int index125_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA125_5 = input.LA(1); + + + int index125_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA125_6 = input.LA(1); + + + int index125_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA125_7 = input.LA(1); + + + int index125_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA125_8 = input.LA(1); + + + int index125_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA125_9 = input.LA(1); + + + int index125_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA125_10 = input.LA(1); + + + int index125_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA125_11 = input.LA(1); + + + int index125_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA125_12 = input.LA(1); + + + int index125_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA125_13 = input.LA(1); + + + int index125_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA125_14 = input.LA(1); + + + int index125_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA125_15 = input.LA(1); + + + int index125_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA125_16 = input.LA(1); + + + int index125_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_PythonPartial()) ) {s = 17;} + + else if ( (true) ) {s = 18;} + + + input.seek(index125_16); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 125, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA123_eotS = + "\30\uffff"; + static final String DFA123_eofS = + "\2\2\26\uffff"; + static final String DFA123_minS = + "\1\7\1\6\26\uffff"; + static final String DFA123_maxS = + "\1\62\1\144\26\uffff"; + static final String DFA123_acceptS = + "\2\uffff\1\2\5\uffff\1\1\17\uffff"; + static final String DFA123_specialS = + "\30\uffff}>"; + static final String[] DFA123_transitionS = { + "\1\2\25\uffff\1\2\21\uffff\1\1\2\uffff\1\2", + "\1\10\1\2\1\uffff\1\10\23\uffff\1\2\15\uffff\1\10\6\uffff\1"+ + "\2\30\uffff\2\10\3\uffff\2\10\1\uffff\1\10\1\uffff\6\10\10\uffff"+ + "\2\10", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA123_eot = DFA.unpackEncodedString(DFA123_eotS); + static final short[] DFA123_eof = DFA.unpackEncodedString(DFA123_eofS); + static final char[] DFA123_min = DFA.unpackEncodedStringToUnsignedChars(DFA123_minS); + static final char[] DFA123_max = DFA.unpackEncodedStringToUnsignedChars(DFA123_maxS); + static final short[] DFA123_accept = DFA.unpackEncodedString(DFA123_acceptS); + static final short[] DFA123_special = DFA.unpackEncodedString(DFA123_specialS); + static final short[][] DFA123_transition; + + static { + int numStates = DFA123_transitionS.length; + DFA123_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA126_transitionS = { + "\1\1", + "\1\3\2\uffff\1\3\41\uffff\1\3\37\uffff\2\3\3\uffff\2\3\1\uffff"+ + "\1\3\1\uffff\6\3\10\uffff\2\3", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA126_eot = DFA.unpackEncodedString(DFA126_eotS); + static final short[] DFA126_eof = DFA.unpackEncodedString(DFA126_eofS); + static final char[] DFA126_min = DFA.unpackEncodedStringToUnsignedChars(DFA126_minS); + static final char[] DFA126_max = DFA.unpackEncodedStringToUnsignedChars(DFA126_maxS); + static final short[] DFA126_accept = DFA.unpackEncodedString(DFA126_acceptS); + static final short[] DFA126_special = DFA.unpackEncodedString(DFA126_specialS); + static final short[][] DFA126_transition; + + static { + int numStates = DFA126_transitionS.length; + DFA126_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA130_transitionS = { + "\1\21\2\uffff\1\11\25\uffff\1\22\1\1\12\uffff\1\5\37\uffff\1"+ + "\2\1\3\3\uffff\1\4\1\6\1\uffff\1\7\1\uffff\1\10\1\12\1\13\1"+ + "\14\1\15\1\16\10\uffff\1\17\1\20", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] DFA130_eot = DFA.unpackEncodedString(DFA130_eotS); + static final short[] DFA130_eof = DFA.unpackEncodedString(DFA130_eofS); + static final char[] DFA130_min = DFA.unpackEncodedStringToUnsignedChars(DFA130_minS); + static final char[] DFA130_max = DFA.unpackEncodedStringToUnsignedChars(DFA130_maxS); + static final short[] DFA130_accept = DFA.unpackEncodedString(DFA130_acceptS); + static final short[] DFA130_special = DFA.unpackEncodedString(DFA130_specialS); + static final short[][] DFA130_transition; + + static { + int numStates = DFA130_transitionS.length; + DFA130_transition = new short[numStates][]; + for (int i=0; i test ( options {k=2; } : COMMA test )* ( COMMA )? | test );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA130_1 = input.LA(1); + + + int index130_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA130_2 = input.LA(1); + + + int index130_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA130_3 = input.LA(1); + + + int index130_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA130_4 = input.LA(1); + + + int index130_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA130_5 = input.LA(1); + + + int index130_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA130_6 = input.LA(1); + + + int index130_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA130_7 = input.LA(1); + + + int index130_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA130_8 = input.LA(1); + + + int index130_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA130_9 = input.LA(1); + + + int index130_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA130_10 = input.LA(1); + + + int index130_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA130_11 = input.LA(1); + + + int index130_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA130_12 = input.LA(1); + + + int index130_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA130_13 = input.LA(1); + + + int index130_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA130_14 = input.LA(1); + + + int index130_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA130_15 = input.LA(1); + + + int index130_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA130_16 = input.LA(1); + + + int index130_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA130_17 = input.LA(1); + + + int index130_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA130_18 = input.LA(1); + + + int index130_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred11_PythonPartial()) ) {s = 19;} + + else if ( (true) ) {s = 20;} + + + input.seek(index130_18); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 130, _s, input); + error(nvae); + throw nvae; + } + } + static final String DFA128_eotS = + "\52\uffff"; + static final String DFA128_eofS = + "\2\2\50\uffff"; + static final String DFA128_minS = + "\1\7\1\6\50\uffff"; + static final String DFA128_maxS = + "\1\125\1\144\50\uffff"; + static final String DFA128_acceptS = + "\2\uffff\1\2\12\uffff\1\1\6\uffff\1\1\25\uffff"; + static final String DFA128_specialS = + "\52\uffff}>"; + static final String[] DFA128_transitionS = { + "\1\2\21\uffff\1\2\1\uffff\1\2\20\uffff\3\2\1\1\2\uffff\15\2"+ + "\23\uffff\1\2\2\uffff\1\2", + "\1\15\1\2\1\uffff\1\15\17\uffff\1\2\1\uffff\1\2\3\uffff\2\15"+ + "\12\uffff\1\15\4\2\2\uffff\15\2\14\uffff\2\15\3\uffff\2\15\1"+ + "\2\1\15\1\uffff\1\24\5\15\10\uffff\2\15", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA128_eot = DFA.unpackEncodedString(DFA128_eotS); + static final short[] DFA128_eof = DFA.unpackEncodedString(DFA128_eofS); + static final char[] DFA128_min = DFA.unpackEncodedStringToUnsignedChars(DFA128_minS); + static final char[] DFA128_max = DFA.unpackEncodedStringToUnsignedChars(DFA128_maxS); + static final short[] DFA128_accept = DFA.unpackEncodedString(DFA128_acceptS); + static final short[] DFA128_special = DFA.unpackEncodedString(DFA128_specialS); + static final short[][] DFA128_transition; + + static { + int numStates = DFA128_transitionS.length; + DFA128_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA131_transitionS = { + "\1\1\44\uffff\1\2", + "\1\4\2\uffff\1\4\25\uffff\2\4\12\uffff\1\4\37\uffff\2\4\3\uffff"+ + "\2\4\1\uffff\1\4\1\2\6\4\10\uffff\2\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] DFA131_eot = DFA.unpackEncodedString(DFA131_eotS); + static final short[] DFA131_eof = DFA.unpackEncodedString(DFA131_eofS); + static final char[] DFA131_min = DFA.unpackEncodedStringToUnsignedChars(DFA131_minS); + static final char[] DFA131_max = DFA.unpackEncodedStringToUnsignedChars(DFA131_maxS); + static final short[] DFA131_accept = DFA.unpackEncodedString(DFA131_acceptS); + static final short[] DFA131_special = DFA.unpackEncodedString(DFA131_specialS); + static final short[][] DFA131_transition; + + static { + int numStates = DFA131_transitionS.length; + DFA131_transition = new short[numStates][]; + for (int i=0; i - +