sandbox/morph / Parser / Python.asdl

Benjamin Peterso… f578ca4 
Jeremy Hylton 1c4d192 
Benjamin Peterso… 0daa6ba 
Jeremy Hylton 1c4d192 

Guido van Rossum 24b6062 
Guido van Rossum 19f7ff4 

Guido van Rossum 24b6062 
Benjamin Peterso… 4e24dfe 
Jeremy Hylton 1c4d192 

Benjamin Peterso… 9b11cc4 
Jeremy Hylton 1c4d192 
Collin Winter 981ecc5 
Benjamin Peterso… e0e6631 
Jeremy Hylton 1c4d192 

Benjamin Peterso… 0704f15 
Jeremy Hylton 1c4d192 

Jeremy Hylton 30e5cb3 
Jeremy Hylton 1c4d192 

Martin von Löwis 57322cb 

Jeremy Hylton 1c4d192 

Thomas Wouters 6165927 
Jeremy Hylton 1c4d192 
Guido van Rossum d0b83c4 
Jeremy Hylton 1c4d192 
Guido van Rossum 090588a 

Jeremy Hylton 1c4d192 
Jeremy Hylton a625e88 
Benjamin Peterso… e1177b9 

Jeremy Hylton 1c4d192 

Benjamin Peterso… f578ca4 
Georg Brandl 7a0ad11 
Jeremy Hylton 1c4d192 

Guido van Rossum e16c8e5 
Jeremy Hylton 1c4d192 

Thomas Wouters 32c4897 
Jeremy Hylton 1c4d192 
Martin von Löwis 57322cb 

Jeremy Hylton 1c4d192 

Georg Brandl 7a0ad11 
Jeremy Hylton 1c4d192 

Neal Norwitz 81ee270 

Jeremy Hylton 1c4d192 
Neal Norwitz 54cd477 

Guido van Rossum 9ad8407 
Jeremy Hylton 1c4d192 

Benjamin Peterso… 9b11cc4 

Jeremy Hylton 1c4d192 
Thomas Wouters bd1419e 
-- ASDL's five builtin types are identifier, int, string, bytes, object

module Python
	mod = Module(stmt* body)
	    | Interactive(stmt* body)
	    | Expression(expr body)

	    -- not really an actual node but useful in Jython's typesystem.
	    | Suite(stmt* body)

	stmt = FunctionDef(identifier name, arguments args, 
                           stmt* body, expr* decorator_list, expr? returns)
	      | ClassDef(identifier name, 
			 expr* bases,
			 keyword* keywords,
			 expr? starargs,
			 expr? kwargs,
			 stmt* body,
			 expr* decorator_list)
	      | Return(expr? value)

	      | Delete(expr* targets)
	      | Assign(expr* targets, expr value)
	      | AugAssign(expr target, operator op, expr value)

	      -- use 'orelse' because else is a keyword in target languages
	      | For(expr target, expr iter, stmt* body, stmt* orelse)
	      | While(expr test, stmt* body, stmt* orelse)
	      | If(expr test, stmt* body, stmt* orelse)
	      | With(withitem* items, stmt* body)

	      | Raise(expr? exc, expr? cause)
	      | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
	      | Assert(expr test, expr? msg)

	      | Import(alias* names)
	      | ImportFrom(identifier? module, alias* names, int? level)

	      | Global(identifier* names)
	      | Nonlocal(identifier* names)
	      | Expr(expr value)
	      | Pass | Break | Continue

	      -- XXX Jython will be different
	      -- col_offset is the byte offset in the utf8 string the parser uses
	      attributes (int lineno, int col_offset)

	      -- BoolOp() can use left & right?
	expr = BoolOp(boolop op, expr* values)
	     | BinOp(expr left, operator op, expr right)
	     | UnaryOp(unaryop op, expr operand)
	     | Lambda(arguments args, expr body)
	     | IfExp(expr test, expr body, expr orelse)
	     | Dict(expr* keys, expr* values)
	     | Set(expr* elts)
	     | ListComp(expr elt, comprehension* generators)
	     | SetComp(expr elt, comprehension* generators)
	     | DictComp(expr key, expr value, comprehension* generators)
	     | GeneratorExp(expr elt, comprehension* generators)
	     -- the grammar constrains where yield expressions can occur
	     | Yield(expr? value)
             | YieldFrom(expr? value)
	     -- need sequences for compare to distinguish between
	     -- x < 4 < 3 and (x < 4) < 3
	     | Compare(expr left, cmpop* ops, expr* comparators)
	     | Call(expr func, expr* args, keyword* keywords,
			 expr? starargs, expr? kwargs)
	     | Num(object n) -- a number as a PyObject.
	     | Str(string s) -- need to specify raw, unicode, etc?
	     | Bytes(bytes s)
	     | Ellipsis
	     -- other literals? bools?

	     -- the following expression can appear in assignment context
	     | Attribute(expr value, identifier attr, expr_context ctx)
	     | Subscript(expr value, slice slice, expr_context ctx)
	     | Starred(expr value, expr_context ctx)
	     | Name(identifier id, expr_context ctx)
	     | List(expr* elts, expr_context ctx) 
	     | Tuple(expr* elts, expr_context ctx)

	      -- col_offset is the byte offset in the utf8 string the parser uses
	      attributes (int lineno, int col_offset)

	expr_context = Load | Store | Del | AugLoad | AugStore | Param

	slice = Slice(expr? lower, expr? upper, expr? step) 
	      | ExtSlice(slice* dims) 
	      | Index(expr value) 

	boolop = And | Or 

	operator = Add | Sub | Mult | Div | Mod | Pow | LShift 
                 | RShift | BitOr | BitXor | BitAnd | FloorDiv

	unaryop = Invert | Not | UAdd | USub

	cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn

	comprehension = (expr target, expr iter, expr* ifs)

	excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
	                attributes (int lineno, int col_offset)

	arguments = (arg* args, identifier? vararg, expr? varargannotation,
                     arg* kwonlyargs, identifier? kwarg,
                     expr? kwargannotation, expr* defaults,
                     expr* kw_defaults)
	arg = (identifier arg, expr? annotation)

        -- keyword arguments supplied to call
        keyword = (identifier arg, expr value)

        -- import name with optional 'as' alias.
        alias = (identifier name, identifier? asname)

        withitem = (expr context_expr, expr? optional_vars)