GeezerVison is showing github.com — gpython/ast/Python.asdl at main · go-python/gpython

Expand file tree

Python.asdl

Copy path

More file actions

Latest commit

History

120 lines (94 loc) · 4.42 KB

Python.asdl

Copy path

File metadata and controls

120 lines (94 loc) · 4.42 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

-- ASDL's six builtin types are identifier, int, string, bytes, object, singleton

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 function, 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)

| NameConstant(singleton value)

| Ellipsis

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

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

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? exprtype, identifier? name, stmt* body)

attributes (int lineno, int col_offset)

arguments = (arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults,

arg? kwarg, expr* defaults)

arg = (identifier arg, expr? annotation)

attributes (int lineno, int col_offset)

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

}