Parser/Python.asdl

   1 -- ASDL's five builtin types are identifier, int, string, object, bool
   2
   3 module Python version "$Revision$"
   4 {
   5         mod = Module(stmt* body)
   6             | Interactive(stmt* body)
   7             | Expression(expr body)
   8
   9             -- not really an actual node but useful in Jython's typesystem.
  10             | Suite(stmt* body)
  11
  12         stmt = FunctionDef(identifier name, arguments args,
  13                             stmt* body, expr* decorator_list)
  14               | ClassDef(identifier name, expr* bases, stmt* body, expr *decorator_list)
  15               | Return(expr? value)
  16
  17               | Delete(expr* targets)
  18               | Assign(expr* targets, expr value)
  19               | AugAssign(expr target, operator op, expr value)
  20
  21               -- not sure if bool is allowed, can always use int
  22               | Print(expr? dest, expr* values, bool nl)
  23
  24               -- use 'orelse' because else is a keyword in target languages
  25               | For(expr target, expr iter, stmt* body, stmt* orelse)
  26               | While(expr test, stmt* body, stmt* orelse)
  27               | If(expr test, stmt* body, stmt* orelse)
  28               | With(expr context_expr, expr? optional_vars, stmt* body)
  29
  30               -- 'type' is a bad name
  31               | Raise(expr? type, expr? inst, expr? tback)
  32               | TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)
  33               | TryFinally(stmt* body, stmt* finalbody)
  34               | Assert(expr test, expr? msg)
  35
  36               | Import(alias* names)
  37               | ImportFrom(identifier module, alias* names, int? level)
  38
  39               -- Doesn't capture requirement that locals must be
  40               -- defined if globals is
  41               -- still supports use as a function!
  42               | Exec(expr body, expr? globals, expr? locals)
  43
  44               | Global(identifier* names)
  45               | Expr(expr value)
  46               | Pass | Break | Continue
  47
  48               -- XXX Jython will be different
  49               -- col_offset is the byte offset in the utf8 string the parser uses
  50               attributes (int lineno, int col_offset)
  51
  52               -- BoolOp() can use left & right?
  53         expr = BoolOp(boolop op, expr* values)
  54              | BinOp(expr left, operator op, expr right)
  55              | UnaryOp(unaryop op, expr operand)
  56              | Lambda(arguments args, expr body)
  57              | IfExp(expr test, expr body, expr orelse)
  58              | Dict(expr* keys, expr* values)
  59              | ListComp(expr elt, comprehension* generators)
  60              | GeneratorExp(expr elt, comprehension* generators)
  61              -- the grammar constrains where yield expressions can occur
  62              | Yield(expr? value)
  63              -- need sequences for compare to distinguish between
  64              -- x < 4 < 3 and (x < 4) < 3
  65              | Compare(expr left, cmpop* ops, expr* comparators)
  66              | Call(expr func, expr* args, keyword* keywords,
  67                          expr? starargs, expr? kwargs)
  68              | Repr(expr value)
  69              | Num(object n) -- a number as a PyObject.
  70              | Str(string s) -- need to specify raw, unicode, etc?
  71              -- other literals? bools?
  72
  73              -- the following expression can appear in assignment context
  74              | Attribute(expr value, identifier attr, expr_context ctx)
  75              | Subscript(expr value, slice slice, expr_context ctx)
  76              | Name(identifier id, expr_context ctx)
  77              | List(expr* elts, expr_context ctx)
  78              | Tuple(expr* elts, expr_context ctx)
  79
  80               -- col_offset is the byte offset in the utf8 string the parser uses
  81               attributes (int lineno, int col_offset)
  82
  83         expr_context = Load | Store | Del | AugLoad | AugStore | Param
  84
  85         slice = Ellipsis | Slice(expr? lower, expr? upper, expr? step)
  86               | ExtSlice(slice* dims)
  87               | Index(expr value)
  88
  89         boolop = And | Or
  90
  91         operator = Add | Sub | Mult | Div | Mod | Pow | LShift
  92                  | RShift | BitOr | BitXor | BitAnd | FloorDiv
  93
  94         unaryop = Invert | Not | UAdd | USub
  95
  96         cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
  97
  98         comprehension = (expr target, expr iter, expr* ifs)
  99
 100         -- not sure what to call the first argument for raise and except
 101         excepthandler = ExceptHandler(expr? type, expr? name, stmt* body)
 102                         attributes (int lineno, int col_offset)
 103
 104         arguments = (expr* args, identifier? vararg,
 105                      identifier? kwarg, expr* defaults)
 106
 107         -- keyword arguments supplied to call
 108         keyword = (identifier arg, expr value)
 109
 110         -- import name with optional 'as' alias.
 111         alias = (identifier name, identifier? asname)
 112 }