thon-slim.2.7.2b2.source-code.PythonParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-slim Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform.
There is a newer version: 2.7.4
Show newest version
// $ANTLR 3.5.2 Python.g 2019-11-01 16:15:32

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
 */
@SuppressWarnings("all")
public class PythonParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"", "", "", "", "ALT_NOTEQUAL", "AMPER", "AMPEREQUAL", 
		"AND", "AS", "ASSERT", "ASSIGN", "AT", "BACKQUOTE", "BREAK", "CIRCUMFLEX", 
		"CIRCUMFLEXEQUAL", "CLASS", "COLON", "COMMA", "COMMENT", "COMPLEX", "CONTINUE", 
		"CONTINUED_LINE", "DEDENT", "DEF", "DELETE", "DIGITS", "DOT", "DOUBLESLASH", 
		"DOUBLESLASHEQUAL", "DOUBLESTAR", "DOUBLESTAREQUAL", "ELIF", "EQUAL", 
		"ESC", "EXCEPT", "EXEC", "Exponent", "FINALLY", "FLOAT", "FOR", "FROM", 
		"GLOBAL", "GREATER", "GREATEREQUAL", "IF", "IMPORT", "IN", "INDENT", "INT", 
		"IS", "LAMBDA", "LBRACK", "LCURLY", "LEADING_WS", "LEFTSHIFT", "LEFTSHIFTEQUAL", 
		"LESS", "LESSEQUAL", "LONGINT", "LPAREN", "MINUS", "MINUSEQUAL", "NAME", 
		"NEWLINE", "NOT", "NOTEQUAL", "OR", "ORELSE", "PASS", "PERCENT", "PERCENTEQUAL", 
		"PLUS", "PLUSEQUAL", "PRINT", "RAISE", "RBRACK", "RCURLY", "RETURN", "RIGHTSHIFT", 
		"RIGHTSHIFTEQUAL", "RPAREN", "SEMI", "SLASH", "SLASHEQUAL", "STAR", "STAREQUAL", 
		"STRING", "TILDE", "TRAILBACKSLASH", "TRIAPOS", "TRIQUOTE", "TRY", "VBAR", 
		"VBAREQUAL", "WHILE", "WITH", "WS", "YIELD"
	};
	public static final int EOF=-1;
	public static final int ALT_NOTEQUAL=4;
	public static final int AMPER=5;
	public static final int AMPEREQUAL=6;
	public static final int AND=7;
	public static final int AS=8;
	public static final int ASSERT=9;
	public static final int ASSIGN=10;
	public static final int AT=11;
	public static final int BACKQUOTE=12;
	public static final int BREAK=13;
	public static final int CIRCUMFLEX=14;
	public static final int CIRCUMFLEXEQUAL=15;
	public static final int CLASS=16;
	public static final int COLON=17;
	public static final int COMMA=18;
	public static final int COMMENT=19;
	public static final int COMPLEX=20;
	public static final int CONTINUE=21;
	public static final int CONTINUED_LINE=22;
	public static final int DEDENT=23;
	public static final int DEF=24;
	public static final int DELETE=25;
	public static final int DIGITS=26;
	public static final int DOT=27;
	public static final int DOUBLESLASH=28;
	public static final int DOUBLESLASHEQUAL=29;
	public static final int DOUBLESTAR=30;
	public static final int DOUBLESTAREQUAL=31;
	public static final int ELIF=32;
	public static final int EQUAL=33;
	public static final int ESC=34;
	public static final int EXCEPT=35;
	public static final int EXEC=36;
	public static final int Exponent=37;
	public static final int FINALLY=38;
	public static final int FLOAT=39;
	public static final int FOR=40;
	public static final int FROM=41;
	public static final int GLOBAL=42;
	public static final int GREATER=43;
	public static final int GREATEREQUAL=44;
	public static final int IF=45;
	public static final int IMPORT=46;
	public static final int IN=47;
	public static final int INDENT=48;
	public static final int INT=49;
	public static final int IS=50;
	public static final int LAMBDA=51;
	public static final int LBRACK=52;
	public static final int LCURLY=53;
	public static final int LEADING_WS=54;
	public static final int LEFTSHIFT=55;
	public static final int LEFTSHIFTEQUAL=56;
	public static final int LESS=57;
	public static final int LESSEQUAL=58;
	public static final int LONGINT=59;
	public static final int LPAREN=60;
	public static final int MINUS=61;
	public static final int MINUSEQUAL=62;
	public static final int NAME=63;
	public static final int NEWLINE=64;
	public static final int NOT=65;
	public static final int NOTEQUAL=66;
	public static final int OR=67;
	public static final int ORELSE=68;
	public static final int PASS=69;
	public static final int PERCENT=70;
	public static final int PERCENTEQUAL=71;
	public static final int PLUS=72;
	public static final int PLUSEQUAL=73;
	public static final int PRINT=74;
	public static final int RAISE=75;
	public static final int RBRACK=76;
	public static final int RCURLY=77;
	public static final int RETURN=78;
	public static final int RIGHTSHIFT=79;
	public static final int RIGHTSHIFTEQUAL=80;
	public static final int RPAREN=81;
	public static final int SEMI=82;
	public static final int SLASH=83;
	public static final int SLASHEQUAL=84;
	public static final int STAR=85;
	public static final int STAREQUAL=86;
	public static final int STRING=87;
	public static final int TILDE=88;
	public static final int TRAILBACKSLASH=89;
	public static final int TRIAPOS=90;
	public static final int TRIQUOTE=91;
	public static final int TRY=92;
	public static final int VBAR=93;
	public static final int VBAREQUAL=94;
	public static final int WHILE=95;
	public static final int WITH=96;
	public static final int WS=97;
	public static final int YIELD=98;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// 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;
	}
	@Override public String[] getTokenNames() { return PythonParser.tokenNames; }
	@Override public String getGrammarFileName() { return "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;
		@Override
		public PythonTree getTree() { return tree; }
	};


	// $ANTLR start "single_input"
	// Python.g:309: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;
		ParserRuleReturnScope simple_stmt3 =null;
		ParserRuleReturnScope 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 {
			// Python.g:316: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==BACKQUOTE||(LA4_0 >= LBRACK && LA4_0 <= LCURLY)||(LA4_0 >= LPAREN && LA4_0 <= MINUS)||LA4_0==NAME||LA4_0==NOT||LA4_0==PLUS||LA4_0==TILDE) ) {
				alt4=2;
			}
			else if ( (LA4_0==PRINT) && (((printFunction)||(!printFunction)))) {
				alt4=2;
			}
			else if ( (LA4_0==ASSERT||LA4_0==BREAK||(LA4_0 >= COMPLEX && LA4_0 <= CONTINUE)||LA4_0==DELETE||LA4_0==EXEC||LA4_0==FLOAT||(LA4_0 >= FROM && LA4_0 <= GLOBAL)||LA4_0==IMPORT||LA4_0==INT||LA4_0==LAMBDA||LA4_0==LONGINT||LA4_0==PASS||LA4_0==RAISE||LA4_0==RETURN||LA4_0==STRING||LA4_0==YIELD) ) {
				alt4=2;
			}
			else if ( (LA4_0==AT||LA4_0==CLASS||LA4_0==DEF||LA4_0==FOR||LA4_0==IF||LA4_0==TRY||(LA4_0 >= WHILE && LA4_0 <= WITH)) ) {
				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 :
					// Python.g:316:7: ( NEWLINE )* EOF
					{
					root_0 = (PythonTree)adaptor.nil();


					// Python.g:316:7: ( NEWLINE )*
					loop1:
					while (true) {
						int alt1=2;
						int LA1_0 = input.LA(1);
						if ( (LA1_0==NEWLINE) ) {
							alt1=1;
						}

						switch (alt1) {
						case 1 :
							// Python.g:316: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;
						}
					}

					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((retval.start), new ArrayList());
					      }
					}
					break;
				case 2 :
					// Python.g:320: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());

					// Python.g:320:19: ( NEWLINE )*
					loop2:
					while (true) {
						int alt2=2;
						int LA2_0 = input.LA(1);
						if ( (LA2_0==NEWLINE) ) {
							alt2=1;
						}

						switch (alt2) {
						case 1 :
							// Python.g:320: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;
						}
					}

					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((retval.start), actions.castStmts((simple_stmt3!=null?((PythonParser.simple_stmt_return)simple_stmt3).stypes:null)));
					      }
					}
					break;
				case 3 :
					// Python.g:324: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());

					// Python.g:324:21: ( NEWLINE )+
					int cnt3=0;
					loop3:
					while (true) {
						int alt3=2;
						int LA3_0 = input.LA(1);
						if ( (LA3_0==NEWLINE) ) {
							alt3=1;
						}

						switch (alt3) {
						case 1 :
							// Python.g:324: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++;
					}

					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((retval.start), actions.castStmts((compound_stmt6!=null?((PythonTree)compound_stmt6.getTree()):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 {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "single_input"


	public static class file_input_return extends ParserRuleReturnScope {
		PythonTree tree;
		@Override
		public PythonTree getTree() { return tree; }
	};


	// $ANTLR start "file_input"
	// Python.g:338: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;
		ParserRuleReturnScope stmt10 =null;

		PythonTree NEWLINE9_tree=null;
		PythonTree EOF11_tree=null;


		    mod mtype = null;
		    List stypes = new ArrayList();

		try {
			// Python.g:356:5: ( ( NEWLINE | stmt )* EOF )
			// Python.g:356:7: ( NEWLINE | stmt )* EOF
			{
			root_0 = (PythonTree)adaptor.nil();


			// Python.g:356:7: ( NEWLINE | stmt )*
			loop5:
			while (true) {
				int alt5=3;
				int LA5_0 = input.LA(1);
				if ( (LA5_0==NEWLINE) ) {
					alt5=1;
				}
				else if ( (LA5_0==BACKQUOTE||(LA5_0 >= LBRACK && LA5_0 <= LCURLY)||(LA5_0 >= LPAREN && LA5_0 <= MINUS)||LA5_0==NAME||LA5_0==NOT||LA5_0==PLUS||LA5_0==TILDE) ) {
					alt5=2;
				}
				else if ( (LA5_0==PRINT) && (((printFunction)||(!printFunction)))) {
					alt5=2;
				}
				else if ( (LA5_0==ASSERT||LA5_0==AT||LA5_0==BREAK||LA5_0==CLASS||(LA5_0 >= COMPLEX && LA5_0 <= CONTINUE)||(LA5_0 >= DEF && LA5_0 <= DELETE)||LA5_0==EXEC||(LA5_0 >= FLOAT && LA5_0 <= GLOBAL)||(LA5_0 >= IF && LA5_0 <= IMPORT)||LA5_0==INT||LA5_0==LAMBDA||LA5_0==LONGINT||LA5_0==PASS||LA5_0==RAISE||LA5_0==RETURN||LA5_0==STRING||LA5_0==TRY||(LA5_0 >= WHILE && LA5_0 <= WITH)||LA5_0==YIELD) ) {
					alt5=2;
				}

				switch (alt5) {
				case 1 :
					// Python.g:356: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 :
					// Python.g:357: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?((PythonParser.stmt_return)stmt10).stypes:null) != null) {
					              stypes.addAll((stmt10!=null?((PythonParser.stmt_return)stmt10).stypes:null));
					          }
					      }
					}
					break;

				default :
					break loop5;
				}
			}

			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((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 {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "file_input"


	public static class eval_input_return extends ParserRuleReturnScope {
		PythonTree tree;
		@Override
		public PythonTree getTree() { return tree; }
	};


	// $ANTLR start "eval_input"
	// Python.g:377: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;
		ParserRuleReturnScope testlist14 =null;

		PythonTree LEADING_WS12_tree=null;
		PythonTree NEWLINE13_tree=null;
		PythonTree NEWLINE15_tree=null;
		PythonTree EOF16_tree=null;


		    mod mtype = null;

		try {
			// Python.g:384:5: ( ( LEADING_WS )? ( NEWLINE )* testlist[expr_contextType.Load] ( NEWLINE )* EOF )
			// Python.g:384:7: ( LEADING_WS )? ( NEWLINE )* testlist[expr_contextType.Load] ( NEWLINE )* EOF
			{
			root_0 = (PythonTree)adaptor.nil();


			// Python.g:384:7: ( LEADING_WS )?
			int alt6=2;
			int LA6_0 = input.LA(1);
			if ( (LA6_0==LEADING_WS) ) {
				alt6=1;
			}
			switch (alt6) {
				case 1 :
					// Python.g:384: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;

			}

			// Python.g:384:19: ( NEWLINE )*
			loop7:
			while (true) {
				int alt7=2;
				int LA7_0 = input.LA(1);
				if ( (LA7_0==NEWLINE) ) {
					alt7=1;
				}

				switch (alt7) {
				case 1 :
					// Python.g:384: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;
				}
			}

			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());

			// Python.g:384:62: ( NEWLINE )*
			loop8:
			while (true) {
				int alt8=2;
				int LA8_0 = input.LA(1);
				if ( (LA8_0==NEWLINE) ) {
					alt8=1;
				}

				switch (alt8) {
				case 1 :
					// Python.g:384: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;
				}
			}

			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((retval.start), actions.castExpr((testlist14!=null?((PythonTree)testlist14.getTree()):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 {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "eval_input"


	public static class dotted_attr_return extends ParserRuleReturnScope {
		public expr etype;
		PythonTree tree;
		@Override
		public PythonTree getTree() { return tree; }
	};


	// $ANTLR start "dotted_attr"
	// Python.g:399: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