| /* File automatically generated by ../Parser/asdl_c.py */ |
| |
| #include "Python.h" |
| #include "Python-ast.h" |
| |
| mod_ty |
| Module(asdl_seq * body) |
| { |
| mod_ty p; |
| p = (mod_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Module_kind; |
| p->v.Module.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Interactive(asdl_seq * body) |
| { |
| mod_ty p; |
| p = (mod_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Interactive_kind; |
| p->v.Interactive.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Expression(expr_ty body) |
| { |
| mod_ty p; |
| if (!body) { |
| PyErr_SetString(PyExc_ValueError, |
| "field body is required for Expression"); |
| return NULL; |
| } |
| p = (mod_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Expression_kind; |
| p->v.Expression.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Suite(asdl_seq * body) |
| { |
| mod_ty p; |
| p = (mod_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Suite_kind; |
| p->v.Suite.body = body; |
| return p; |
| } |
| |
| stmt_ty |
| FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * |
| decorators, int lineno) |
| { |
| stmt_ty p; |
| if (!name) { |
| PyErr_SetString(PyExc_ValueError, |
| "field name is required for FunctionDef"); |
| return NULL; |
| } |
| if (!args) { |
| PyErr_SetString(PyExc_ValueError, |
| "field args is required for FunctionDef"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = FunctionDef_kind; |
| p->v.FunctionDef.name = name; |
| p->v.FunctionDef.args = args; |
| p->v.FunctionDef.body = body; |
| p->v.FunctionDef.decorators = decorators; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno) |
| { |
| stmt_ty p; |
| if (!name) { |
| PyErr_SetString(PyExc_ValueError, |
| "field name is required for ClassDef"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = ClassDef_kind; |
| p->v.ClassDef.name = name; |
| p->v.ClassDef.bases = bases; |
| p->v.ClassDef.body = body; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Return(expr_ty value, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Return_kind; |
| p->v.Return.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Delete(asdl_seq * targets, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Delete_kind; |
| p->v.Delete.targets = targets; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Assign(asdl_seq * targets, expr_ty value, int lineno) |
| { |
| stmt_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Assign"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Assign_kind; |
| p->v.Assign.targets = targets; |
| p->v.Assign.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno) |
| { |
| stmt_ty p; |
| if (!target) { |
| PyErr_SetString(PyExc_ValueError, |
| "field target is required for AugAssign"); |
| return NULL; |
| } |
| if (!op) { |
| PyErr_SetString(PyExc_ValueError, |
| "field op is required for AugAssign"); |
| return NULL; |
| } |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for AugAssign"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = AugAssign_kind; |
| p->v.AugAssign.target = target; |
| p->v.AugAssign.op = op; |
| p->v.AugAssign.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Print(expr_ty dest, asdl_seq * values, bool nl, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Print_kind; |
| p->v.Print.dest = dest; |
| p->v.Print.values = values; |
| p->v.Print.nl = nl; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int |
| lineno) |
| { |
| stmt_ty p; |
| if (!target) { |
| PyErr_SetString(PyExc_ValueError, |
| "field target is required for For"); |
| return NULL; |
| } |
| if (!iter) { |
| PyErr_SetString(PyExc_ValueError, |
| "field iter is required for For"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = For_kind; |
| p->v.For.target = target; |
| p->v.For.iter = iter; |
| p->v.For.body = body; |
| p->v.For.orelse = orelse; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for While"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = While_kind; |
| p->v.While.test = test; |
| p->v.While.body = body; |
| p->v.While.orelse = orelse; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for If"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = If_kind; |
| p->v.If.test = test; |
| p->v.If.body = body; |
| p->v.If.orelse = orelse; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Raise_kind; |
| p->v.Raise.type = type; |
| p->v.Raise.inst = inst; |
| p->v.Raise.tback = tback; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = TryExcept_kind; |
| p->v.TryExcept.body = body; |
| p->v.TryExcept.handlers = handlers; |
| p->v.TryExcept.orelse = orelse; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = TryFinally_kind; |
| p->v.TryFinally.body = body; |
| p->v.TryFinally.finalbody = finalbody; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Assert(expr_ty test, expr_ty msg, int lineno) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for Assert"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Assert_kind; |
| p->v.Assert.test = test; |
| p->v.Assert.msg = msg; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Import(asdl_seq * names, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Import_kind; |
| p->v.Import.names = names; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| ImportFrom(identifier module, asdl_seq * names, int lineno) |
| { |
| stmt_ty p; |
| if (!module) { |
| PyErr_SetString(PyExc_ValueError, |
| "field module is required for ImportFrom"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = ImportFrom_kind; |
| p->v.ImportFrom.module = module; |
| p->v.ImportFrom.names = names; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno) |
| { |
| stmt_ty p; |
| if (!body) { |
| PyErr_SetString(PyExc_ValueError, |
| "field body is required for Exec"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Exec_kind; |
| p->v.Exec.body = body; |
| p->v.Exec.globals = globals; |
| p->v.Exec.locals = locals; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Global(asdl_seq * names, int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Global_kind; |
| p->v.Global.names = names; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Expr(expr_ty value, int lineno) |
| { |
| stmt_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Expr"); |
| return NULL; |
| } |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Expr_kind; |
| p->v.Expr.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Pass(int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Pass_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Break(int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Break_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Continue(int lineno) |
| { |
| stmt_ty p; |
| p = (stmt_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Continue_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| BoolOp(boolop_ty op, asdl_seq * values, int lineno) |
| { |
| expr_ty p; |
| if (!op) { |
| PyErr_SetString(PyExc_ValueError, |
| "field op is required for BoolOp"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = BoolOp_kind; |
| p->v.BoolOp.op = op; |
| p->v.BoolOp.values = values; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno) |
| { |
| expr_ty p; |
| if (!left) { |
| PyErr_SetString(PyExc_ValueError, |
| "field left is required for BinOp"); |
| return NULL; |
| } |
| if (!op) { |
| PyErr_SetString(PyExc_ValueError, |
| "field op is required for BinOp"); |
| return NULL; |
| } |
| if (!right) { |
| PyErr_SetString(PyExc_ValueError, |
| "field right is required for BinOp"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = BinOp_kind; |
| p->v.BinOp.left = left; |
| p->v.BinOp.op = op; |
| p->v.BinOp.right = right; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| UnaryOp(unaryop_ty op, expr_ty operand, int lineno) |
| { |
| expr_ty p; |
| if (!op) { |
| PyErr_SetString(PyExc_ValueError, |
| "field op is required for UnaryOp"); |
| return NULL; |
| } |
| if (!operand) { |
| PyErr_SetString(PyExc_ValueError, |
| "field operand is required for UnaryOp"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = UnaryOp_kind; |
| p->v.UnaryOp.op = op; |
| p->v.UnaryOp.operand = operand; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Lambda(arguments_ty args, expr_ty body, int lineno) |
| { |
| expr_ty p; |
| if (!args) { |
| PyErr_SetString(PyExc_ValueError, |
| "field args is required for Lambda"); |
| return NULL; |
| } |
| if (!body) { |
| PyErr_SetString(PyExc_ValueError, |
| "field body is required for Lambda"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Lambda_kind; |
| p->v.Lambda.args = args; |
| p->v.Lambda.body = body; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Dict(asdl_seq * keys, asdl_seq * values, int lineno) |
| { |
| expr_ty p; |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Dict_kind; |
| p->v.Dict.keys = keys; |
| p->v.Dict.values = values; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| ListComp(expr_ty elt, asdl_seq * generators, int lineno) |
| { |
| expr_ty p; |
| if (!elt) { |
| PyErr_SetString(PyExc_ValueError, |
| "field elt is required for ListComp"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = ListComp_kind; |
| p->v.ListComp.elt = elt; |
| p->v.ListComp.generators = generators; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno) |
| { |
| expr_ty p; |
| if (!elt) { |
| PyErr_SetString(PyExc_ValueError, |
| "field elt is required for GeneratorExp"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = GeneratorExp_kind; |
| p->v.GeneratorExp.elt = elt; |
| p->v.GeneratorExp.generators = generators; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Yield(expr_ty value, int lineno) |
| { |
| expr_ty p; |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Yield_kind; |
| p->v.Yield.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Compare(expr_ty left, asdl_seq * ops, asdl_seq * comparators, int lineno) |
| { |
| expr_ty p; |
| if (!left) { |
| PyErr_SetString(PyExc_ValueError, |
| "field left is required for Compare"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Compare_kind; |
| p->v.Compare.left = left; |
| p->v.Compare.ops = ops; |
| p->v.Compare.comparators = comparators; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, |
| expr_ty kwargs, int lineno) |
| { |
| expr_ty p; |
| if (!func) { |
| PyErr_SetString(PyExc_ValueError, |
| "field func is required for Call"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Call_kind; |
| p->v.Call.func = func; |
| p->v.Call.args = args; |
| p->v.Call.keywords = keywords; |
| p->v.Call.starargs = starargs; |
| p->v.Call.kwargs = kwargs; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Repr(expr_ty value, int lineno) |
| { |
| expr_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Repr"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Repr_kind; |
| p->v.Repr.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Num(object n, int lineno) |
| { |
| expr_ty p; |
| if (!n) { |
| PyErr_SetString(PyExc_ValueError, |
| "field n is required for Num"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Num_kind; |
| p->v.Num.n = n; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Str(string s, int lineno) |
| { |
| expr_ty p; |
| if (!s) { |
| PyErr_SetString(PyExc_ValueError, |
| "field s is required for Str"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Str_kind; |
| p->v.Str.s = s; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno) |
| { |
| expr_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Attribute"); |
| return NULL; |
| } |
| if (!attr) { |
| PyErr_SetString(PyExc_ValueError, |
| "field attr is required for Attribute"); |
| return NULL; |
| } |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for Attribute"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Attribute_kind; |
| p->v.Attribute.value = value; |
| p->v.Attribute.attr = attr; |
| p->v.Attribute.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno) |
| { |
| expr_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Subscript"); |
| return NULL; |
| } |
| if (!slice) { |
| PyErr_SetString(PyExc_ValueError, |
| "field slice is required for Subscript"); |
| return NULL; |
| } |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for Subscript"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Subscript_kind; |
| p->v.Subscript.value = value; |
| p->v.Subscript.slice = slice; |
| p->v.Subscript.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Name(identifier id, expr_context_ty ctx, int lineno) |
| { |
| expr_ty p; |
| if (!id) { |
| PyErr_SetString(PyExc_ValueError, |
| "field id is required for Name"); |
| return NULL; |
| } |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for Name"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Name_kind; |
| p->v.Name.id = id; |
| p->v.Name.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| List(asdl_seq * elts, expr_context_ty ctx, int lineno) |
| { |
| expr_ty p; |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for List"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = List_kind; |
| p->v.List.elts = elts; |
| p->v.List.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno) |
| { |
| expr_ty p; |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for Tuple"); |
| return NULL; |
| } |
| p = (expr_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Tuple_kind; |
| p->v.Tuple.elts = elts; |
| p->v.Tuple.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| slice_ty |
| Ellipsis() |
| { |
| slice_ty p; |
| p = (slice_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Ellipsis_kind; |
| return p; |
| } |
| |
| slice_ty |
| Slice(expr_ty lower, expr_ty upper, expr_ty step) |
| { |
| slice_ty p; |
| p = (slice_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Slice_kind; |
| p->v.Slice.lower = lower; |
| p->v.Slice.upper = upper; |
| p->v.Slice.step = step; |
| return p; |
| } |
| |
| slice_ty |
| ExtSlice(asdl_seq * dims) |
| { |
| slice_ty p; |
| p = (slice_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = ExtSlice_kind; |
| p->v.ExtSlice.dims = dims; |
| return p; |
| } |
| |
| slice_ty |
| Index(expr_ty value) |
| { |
| slice_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Index"); |
| return NULL; |
| } |
| p = (slice_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->kind = Index_kind; |
| p->v.Index.value = value; |
| return p; |
| } |
| |
| comprehension_ty |
| comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs) |
| { |
| comprehension_ty p; |
| if (!target) { |
| PyErr_SetString(PyExc_ValueError, |
| "field target is required for comprehension"); |
| return NULL; |
| } |
| if (!iter) { |
| PyErr_SetString(PyExc_ValueError, |
| "field iter is required for comprehension"); |
| return NULL; |
| } |
| p = (comprehension_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->target = target; |
| p->iter = iter; |
| p->ifs = ifs; |
| return p; |
| } |
| |
| excepthandler_ty |
| excepthandler(expr_ty type, expr_ty name, asdl_seq * body) |
| { |
| excepthandler_ty p; |
| p = (excepthandler_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->type = type; |
| p->name = name; |
| p->body = body; |
| return p; |
| } |
| |
| arguments_ty |
| arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq * |
| defaults) |
| { |
| arguments_ty p; |
| p = (arguments_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->args = args; |
| p->vararg = vararg; |
| p->kwarg = kwarg; |
| p->defaults = defaults; |
| return p; |
| } |
| |
| keyword_ty |
| keyword(identifier arg, expr_ty value) |
| { |
| keyword_ty p; |
| if (!arg) { |
| PyErr_SetString(PyExc_ValueError, |
| "field arg is required for keyword"); |
| return NULL; |
| } |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for keyword"); |
| return NULL; |
| } |
| p = (keyword_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->arg = arg; |
| p->value = value; |
| return p; |
| } |
| |
| alias_ty |
| alias(identifier name, identifier asname) |
| { |
| alias_ty p; |
| if (!name) { |
| PyErr_SetString(PyExc_ValueError, |
| "field name is required for alias"); |
| return NULL; |
| } |
| p = (alias_ty)malloc(sizeof(*p)); |
| if (!p) { |
| PyErr_SetString(PyExc_MemoryError, "no memory"); |
| return NULL; |
| } |
| p->name = name; |
| p->asname = asname; |
| return p; |
| } |
| |
| static void |
| free_seq_exprs(asdl_seq *seq) |
| { |
| int i, n; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_expr((expr_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| } |
| |
| static void |
| free_seq_stmts(asdl_seq *seq) |
| { |
| int i, n; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_stmt((stmt_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| } |
| |
| void |
| free_mod(mod_ty o) |
| { |
| if (!o) |
| return; |
| |
| switch (o->kind) { |
| case Module_kind: |
| free_seq_stmts(o->v.Module.body); |
| break; |
| case Interactive_kind: |
| free_seq_stmts(o->v.Interactive.body); |
| break; |
| case Expression_kind: |
| free_expr((expr_ty)o->v.Expression.body); |
| break; |
| case Suite_kind: |
| free_seq_stmts(o->v.Suite.body); |
| break; |
| } |
| |
| free(o); |
| } |
| |
| void |
| free_stmt(stmt_ty o) |
| { |
| int i, n; |
| asdl_seq *seq; |
| |
| if (!o) |
| return; |
| |
| switch (o->kind) { |
| case FunctionDef_kind: |
| Py_DECREF((identifier)o->v.FunctionDef.name); |
| free_arguments((arguments_ty)o->v.FunctionDef.args); |
| free_seq_stmts(o->v.FunctionDef.body); |
| free_seq_exprs(o->v.FunctionDef.decorators); |
| break; |
| case ClassDef_kind: |
| Py_DECREF((identifier)o->v.ClassDef.name); |
| free_seq_exprs(o->v.ClassDef.bases); |
| free_seq_stmts(o->v.ClassDef.body); |
| break; |
| case Return_kind: |
| if (o->v.Return.value) { |
| free_expr((expr_ty)o->v.Return.value); |
| } |
| break; |
| case Delete_kind: |
| free_seq_exprs(o->v.Delete.targets); |
| break; |
| case Assign_kind: |
| free_seq_exprs(o->v.Assign.targets); |
| free_expr((expr_ty)o->v.Assign.value); |
| break; |
| case AugAssign_kind: |
| free_expr((expr_ty)o->v.AugAssign.target); |
| free_operator((operator_ty)o->v.AugAssign.op); |
| free_expr((expr_ty)o->v.AugAssign.value); |
| break; |
| case Print_kind: |
| if (o->v.Print.dest) { |
| free_expr((expr_ty)o->v.Print.dest); |
| } |
| free_seq_exprs(o->v.Print.values); |
| break; |
| case For_kind: |
| free_expr((expr_ty)o->v.For.target); |
| free_expr((expr_ty)o->v.For.iter); |
| free_seq_stmts(o->v.For.body); |
| free_seq_stmts(o->v.For.orelse); |
| break; |
| case While_kind: |
| free_expr((expr_ty)o->v.While.test); |
| free_seq_stmts(o->v.While.body); |
| free_seq_stmts(o->v.While.orelse); |
| break; |
| case If_kind: |
| free_expr((expr_ty)o->v.If.test); |
| free_seq_stmts(o->v.If.body); |
| free_seq_stmts(o->v.If.orelse); |
| break; |
| case Raise_kind: |
| if (o->v.Raise.type) { |
| free_expr((expr_ty)o->v.Raise.type); |
| } |
| if (o->v.Raise.inst) { |
| free_expr((expr_ty)o->v.Raise.inst); |
| } |
| if (o->v.Raise.tback) { |
| free_expr((expr_ty)o->v.Raise.tback); |
| } |
| break; |
| case TryExcept_kind: |
| free_seq_stmts(o->v.TryExcept.body); |
| seq = o->v.TryExcept.handlers; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_excepthandler((excepthandler_ty)asdl_seq_GET(seq, |
| i)); |
| asdl_seq_free(seq); |
| free_seq_stmts(o->v.TryExcept.orelse); |
| break; |
| case TryFinally_kind: |
| free_seq_stmts(o->v.TryFinally.body); |
| free_seq_stmts(o->v.TryFinally.finalbody); |
| break; |
| case Assert_kind: |
| free_expr((expr_ty)o->v.Assert.test); |
| if (o->v.Assert.msg) { |
| free_expr((expr_ty)o->v.Assert.msg); |
| } |
| break; |
| case Import_kind: |
| seq = o->v.Import.names; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_alias((alias_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| break; |
| case ImportFrom_kind: |
| Py_DECREF((identifier)o->v.ImportFrom.module); |
| seq = o->v.ImportFrom.names; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_alias((alias_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| break; |
| case Exec_kind: |
| free_expr((expr_ty)o->v.Exec.body); |
| if (o->v.Exec.globals) { |
| free_expr((expr_ty)o->v.Exec.globals); |
| } |
| if (o->v.Exec.locals) { |
| free_expr((expr_ty)o->v.Exec.locals); |
| } |
| break; |
| case Global_kind: |
| seq = o->v.Global.names; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| Py_DECREF((identifier)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| break; |
| case Expr_kind: |
| free_expr((expr_ty)o->v.Expr.value); |
| break; |
| case Pass_kind: |
| break; |
| case Break_kind: |
| break; |
| case Continue_kind: |
| break; |
| } |
| |
| free(o); |
| } |
| |
| void |
| free_expr(expr_ty o) |
| { |
| int i, n; |
| asdl_seq *seq; |
| |
| if (!o) |
| return; |
| |
| switch (o->kind) { |
| case BoolOp_kind: |
| free_boolop((boolop_ty)o->v.BoolOp.op); |
| free_seq_exprs(o->v.BoolOp.values); |
| break; |
| case BinOp_kind: |
| free_expr((expr_ty)o->v.BinOp.left); |
| free_operator((operator_ty)o->v.BinOp.op); |
| free_expr((expr_ty)o->v.BinOp.right); |
| break; |
| case UnaryOp_kind: |
| free_unaryop((unaryop_ty)o->v.UnaryOp.op); |
| free_expr((expr_ty)o->v.UnaryOp.operand); |
| break; |
| case Lambda_kind: |
| free_arguments((arguments_ty)o->v.Lambda.args); |
| free_expr((expr_ty)o->v.Lambda.body); |
| break; |
| case Dict_kind: |
| free_seq_exprs(o->v.Dict.keys); |
| free_seq_exprs(o->v.Dict.values); |
| break; |
| case ListComp_kind: |
| free_expr((expr_ty)o->v.ListComp.elt); |
| seq = o->v.ListComp.generators; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_comprehension((comprehension_ty)asdl_seq_GET(seq, |
| i)); |
| asdl_seq_free(seq); |
| break; |
| case GeneratorExp_kind: |
| free_expr((expr_ty)o->v.GeneratorExp.elt); |
| seq = o->v.GeneratorExp.generators; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_comprehension((comprehension_ty)asdl_seq_GET(seq, |
| i)); |
| asdl_seq_free(seq); |
| break; |
| case Yield_kind: |
| if (o->v.Yield.value) { |
| free_expr((expr_ty)o->v.Yield.value); |
| } |
| break; |
| case Compare_kind: |
| free_expr((expr_ty)o->v.Compare.left); |
| seq = o->v.Compare.ops; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_cmpop((cmpop_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| free_seq_exprs(o->v.Compare.comparators); |
| break; |
| case Call_kind: |
| free_expr((expr_ty)o->v.Call.func); |
| free_seq_exprs(o->v.Call.args); |
| seq = o->v.Call.keywords; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_keyword((keyword_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| if (o->v.Call.starargs) { |
| free_expr((expr_ty)o->v.Call.starargs); |
| } |
| if (o->v.Call.kwargs) { |
| free_expr((expr_ty)o->v.Call.kwargs); |
| } |
| break; |
| case Repr_kind: |
| free_expr((expr_ty)o->v.Repr.value); |
| break; |
| case Num_kind: |
| Py_DECREF((object)o->v.Num.n); |
| break; |
| case Str_kind: |
| Py_DECREF((string)o->v.Str.s); |
| break; |
| case Attribute_kind: |
| free_expr((expr_ty)o->v.Attribute.value); |
| Py_DECREF((identifier)o->v.Attribute.attr); |
| free_expr_context((expr_context_ty)o->v.Attribute.ctx); |
| break; |
| case Subscript_kind: |
| free_expr((expr_ty)o->v.Subscript.value); |
| free_slice((slice_ty)o->v.Subscript.slice); |
| free_expr_context((expr_context_ty)o->v.Subscript.ctx); |
| break; |
| case Name_kind: |
| Py_DECREF((identifier)o->v.Name.id); |
| free_expr_context((expr_context_ty)o->v.Name.ctx); |
| break; |
| case List_kind: |
| free_seq_exprs(o->v.List.elts); |
| free_expr_context((expr_context_ty)o->v.List.ctx); |
| break; |
| case Tuple_kind: |
| free_seq_exprs(o->v.Tuple.elts); |
| free_expr_context((expr_context_ty)o->v.Tuple.ctx); |
| break; |
| } |
| |
| free(o); |
| } |
| |
| void |
| free_expr_context(expr_context_ty o) |
| { |
| if (!o) |
| return; |
| |
| } |
| |
| void |
| free_slice(slice_ty o) |
| { |
| int i, n; |
| asdl_seq *seq; |
| |
| if (!o) |
| return; |
| |
| switch (o->kind) { |
| case Ellipsis_kind: |
| break; |
| case Slice_kind: |
| if (o->v.Slice.lower) { |
| free_expr((expr_ty)o->v.Slice.lower); |
| } |
| if (o->v.Slice.upper) { |
| free_expr((expr_ty)o->v.Slice.upper); |
| } |
| if (o->v.Slice.step) { |
| free_expr((expr_ty)o->v.Slice.step); |
| } |
| break; |
| case ExtSlice_kind: |
| seq = o->v.ExtSlice.dims; |
| n = asdl_seq_LEN(seq); |
| for (i = 0; i < n; i++) |
| free_slice((slice_ty)asdl_seq_GET(seq, i)); |
| asdl_seq_free(seq); |
| break; |
| case Index_kind: |
| free_expr((expr_ty)o->v.Index.value); |
| break; |
| } |
| |
| free(o); |
| } |
| |
| void |
| free_boolop(boolop_ty o) |
| { |
| if (!o) |
| return; |
| |
| } |
| |
| void |
| free_operator(operator_ty o) |
| { |
| if (!o) |
| return; |
| |
| } |
| |
| void |
| free_unaryop(unaryop_ty o) |
| { |
| if (!o) |
| return; |
| |
| } |
| |
| void |
| free_cmpop(cmpop_ty o) |
| { |
| if (!o) |
| return; |
| |
| } |
| |
| void |
| free_comprehension(comprehension_ty o) |
| { |
| if (!o) |
| return; |
| |
| free_expr((expr_ty)o->target); |
| free_expr((expr_ty)o->iter); |
| free_seq_exprs(o->ifs); |
| |
| free(o); |
| } |
| |
| void |
| free_excepthandler(excepthandler_ty o) |
| { |
| if (!o) |
| return; |
| |
| if (o->type) { |
| free_expr((expr_ty)o->type); |
| } |
| if (o->name) { |
| free_expr((expr_ty)o->name); |
| } |
| free_seq_stmts(o->body); |
| |
| free(o); |
| } |
| |
| void |
| free_arguments(arguments_ty o) |
| { |
| if (!o) |
| return; |
| |
| free_seq_exprs(o->args); |
| if (o->vararg) { |
| Py_DECREF((identifier)o->vararg); |
| } |
| if (o->kwarg) { |
| Py_DECREF((identifier)o->kwarg); |
| } |
| free_seq_exprs(o->defaults); |
| |
| free(o); |
| } |
| |
| void |
| free_keyword(keyword_ty o) |
| { |
| if (!o) |
| return; |
| |
| Py_DECREF((identifier)o->arg); |
| free_expr((expr_ty)o->value); |
| |
| free(o); |
| } |
| |
| void |
| free_alias(alias_ty o) |
| { |
| if (!o) |
| return; |
| |
| Py_DECREF((identifier)o->name); |
| if (o->asname) { |
| Py_DECREF((identifier)o->asname); |
| } |
| |
| free(o); |
| } |
| |
| int |
| marshal_write_mod(PyObject **buf, int *off, mod_ty o) |
| { |
| int i; |
| switch (o->kind) { |
| case Module_kind: |
| marshal_write_int(buf, off, 1); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Module.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Module.body); i++) { |
| void *elt = asdl_seq_GET(o->v.Module.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case Interactive_kind: |
| marshal_write_int(buf, off, 2); |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.Interactive.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Interactive.body); i++) { |
| void *elt = asdl_seq_GET(o->v.Interactive.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case Expression_kind: |
| marshal_write_int(buf, off, 3); |
| marshal_write_expr(buf, off, o->v.Expression.body); |
| break; |
| case Suite_kind: |
| marshal_write_int(buf, off, 4); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Suite.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Suite.body); i++) { |
| void *elt = asdl_seq_GET(o->v.Suite.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_stmt(PyObject **buf, int *off, stmt_ty o) |
| { |
| int i; |
| switch (o->kind) { |
| case FunctionDef_kind: |
| marshal_write_int(buf, off, 1); |
| marshal_write_identifier(buf, off, o->v.FunctionDef.name); |
| marshal_write_arguments(buf, off, o->v.FunctionDef.args); |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.FunctionDef.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.FunctionDef.body); i++) { |
| void *elt = asdl_seq_GET(o->v.FunctionDef.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.FunctionDef.decorators)); |
| for (i = 0; i < asdl_seq_LEN(o->v.FunctionDef.decorators); i++) |
| { |
| void *elt = asdl_seq_GET(o->v.FunctionDef.decorators, |
| i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| break; |
| case ClassDef_kind: |
| marshal_write_int(buf, off, 2); |
| marshal_write_identifier(buf, off, o->v.ClassDef.name); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.ClassDef.bases)); |
| for (i = 0; i < asdl_seq_LEN(o->v.ClassDef.bases); i++) { |
| void *elt = asdl_seq_GET(o->v.ClassDef.bases, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.ClassDef.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.ClassDef.body); i++) { |
| void *elt = asdl_seq_GET(o->v.ClassDef.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case Return_kind: |
| marshal_write_int(buf, off, 3); |
| if (o->v.Return.value) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Return.value); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case Delete_kind: |
| marshal_write_int(buf, off, 4); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Delete.targets)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Delete.targets); i++) { |
| void *elt = asdl_seq_GET(o->v.Delete.targets, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| break; |
| case Assign_kind: |
| marshal_write_int(buf, off, 5); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Assign.targets)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Assign.targets); i++) { |
| void *elt = asdl_seq_GET(o->v.Assign.targets, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_expr(buf, off, o->v.Assign.value); |
| break; |
| case AugAssign_kind: |
| marshal_write_int(buf, off, 6); |
| marshal_write_expr(buf, off, o->v.AugAssign.target); |
| marshal_write_operator(buf, off, o->v.AugAssign.op); |
| marshal_write_expr(buf, off, o->v.AugAssign.value); |
| break; |
| case Print_kind: |
| marshal_write_int(buf, off, 7); |
| if (o->v.Print.dest) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Print.dest); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Print.values)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Print.values); i++) { |
| void *elt = asdl_seq_GET(o->v.Print.values, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_bool(buf, off, o->v.Print.nl); |
| break; |
| case For_kind: |
| marshal_write_int(buf, off, 8); |
| marshal_write_expr(buf, off, o->v.For.target); |
| marshal_write_expr(buf, off, o->v.For.iter); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.For.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.For.body); i++) { |
| void *elt = asdl_seq_GET(o->v.For.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.For.orelse)); |
| for (i = 0; i < asdl_seq_LEN(o->v.For.orelse); i++) { |
| void *elt = asdl_seq_GET(o->v.For.orelse, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case While_kind: |
| marshal_write_int(buf, off, 9); |
| marshal_write_expr(buf, off, o->v.While.test); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.While.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.While.body); i++) { |
| void *elt = asdl_seq_GET(o->v.While.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.While.orelse)); |
| for (i = 0; i < asdl_seq_LEN(o->v.While.orelse); i++) { |
| void *elt = asdl_seq_GET(o->v.While.orelse, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case If_kind: |
| marshal_write_int(buf, off, 10); |
| marshal_write_expr(buf, off, o->v.If.test); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.If.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.If.body); i++) { |
| void *elt = asdl_seq_GET(o->v.If.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.If.orelse)); |
| for (i = 0; i < asdl_seq_LEN(o->v.If.orelse); i++) { |
| void *elt = asdl_seq_GET(o->v.If.orelse, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case Raise_kind: |
| marshal_write_int(buf, off, 11); |
| if (o->v.Raise.type) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Raise.type); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Raise.inst) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Raise.inst); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Raise.tback) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Raise.tback); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case TryExcept_kind: |
| marshal_write_int(buf, off, 12); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.TryExcept.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.body); i++) { |
| void *elt = asdl_seq_GET(o->v.TryExcept.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.TryExcept.handlers)); |
| for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.handlers); i++) { |
| void *elt = asdl_seq_GET(o->v.TryExcept.handlers, i); |
| marshal_write_excepthandler(buf, off, |
| (excepthandler_ty)elt); |
| } |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.TryExcept.orelse)); |
| for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.orelse); i++) { |
| void *elt = asdl_seq_GET(o->v.TryExcept.orelse, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case TryFinally_kind: |
| marshal_write_int(buf, off, 13); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.TryFinally.body)); |
| for (i = 0; i < asdl_seq_LEN(o->v.TryFinally.body); i++) { |
| void *elt = asdl_seq_GET(o->v.TryFinally.body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.TryFinally.finalbody)); |
| for (i = 0; i < asdl_seq_LEN(o->v.TryFinally.finalbody); i++) { |
| void *elt = asdl_seq_GET(o->v.TryFinally.finalbody, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| break; |
| case Assert_kind: |
| marshal_write_int(buf, off, 14); |
| marshal_write_expr(buf, off, o->v.Assert.test); |
| if (o->v.Assert.msg) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Assert.msg); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case Import_kind: |
| marshal_write_int(buf, off, 15); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Import.names)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Import.names); i++) { |
| void *elt = asdl_seq_GET(o->v.Import.names, i); |
| marshal_write_alias(buf, off, (alias_ty)elt); |
| } |
| break; |
| case ImportFrom_kind: |
| marshal_write_int(buf, off, 16); |
| marshal_write_identifier(buf, off, o->v.ImportFrom.module); |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.ImportFrom.names)); |
| for (i = 0; i < asdl_seq_LEN(o->v.ImportFrom.names); i++) { |
| void *elt = asdl_seq_GET(o->v.ImportFrom.names, i); |
| marshal_write_alias(buf, off, (alias_ty)elt); |
| } |
| break; |
| case Exec_kind: |
| marshal_write_int(buf, off, 17); |
| marshal_write_expr(buf, off, o->v.Exec.body); |
| if (o->v.Exec.globals) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Exec.globals); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Exec.locals) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Exec.locals); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case Global_kind: |
| marshal_write_int(buf, off, 18); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Global.names)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Global.names); i++) { |
| void *elt = asdl_seq_GET(o->v.Global.names, i); |
| marshal_write_identifier(buf, off, (identifier)elt); |
| } |
| break; |
| case Expr_kind: |
| marshal_write_int(buf, off, 19); |
| marshal_write_expr(buf, off, o->v.Expr.value); |
| break; |
| case Pass_kind: |
| marshal_write_int(buf, off, 20); |
| break; |
| case Break_kind: |
| marshal_write_int(buf, off, 21); |
| break; |
| case Continue_kind: |
| marshal_write_int(buf, off, 22); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_expr(PyObject **buf, int *off, expr_ty o) |
| { |
| int i; |
| switch (o->kind) { |
| case BoolOp_kind: |
| marshal_write_int(buf, off, 1); |
| marshal_write_boolop(buf, off, o->v.BoolOp.op); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.BoolOp.values)); |
| for (i = 0; i < asdl_seq_LEN(o->v.BoolOp.values); i++) { |
| void *elt = asdl_seq_GET(o->v.BoolOp.values, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| break; |
| case BinOp_kind: |
| marshal_write_int(buf, off, 2); |
| marshal_write_expr(buf, off, o->v.BinOp.left); |
| marshal_write_operator(buf, off, o->v.BinOp.op); |
| marshal_write_expr(buf, off, o->v.BinOp.right); |
| break; |
| case UnaryOp_kind: |
| marshal_write_int(buf, off, 3); |
| marshal_write_unaryop(buf, off, o->v.UnaryOp.op); |
| marshal_write_expr(buf, off, o->v.UnaryOp.operand); |
| break; |
| case Lambda_kind: |
| marshal_write_int(buf, off, 4); |
| marshal_write_arguments(buf, off, o->v.Lambda.args); |
| marshal_write_expr(buf, off, o->v.Lambda.body); |
| break; |
| case Dict_kind: |
| marshal_write_int(buf, off, 5); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Dict.keys)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Dict.keys); i++) { |
| void *elt = asdl_seq_GET(o->v.Dict.keys, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Dict.values)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Dict.values); i++) { |
| void *elt = asdl_seq_GET(o->v.Dict.values, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| break; |
| case ListComp_kind: |
| marshal_write_int(buf, off, 6); |
| marshal_write_expr(buf, off, o->v.ListComp.elt); |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.ListComp.generators)); |
| for (i = 0; i < asdl_seq_LEN(o->v.ListComp.generators); i++) { |
| void *elt = asdl_seq_GET(o->v.ListComp.generators, i); |
| marshal_write_comprehension(buf, off, |
| (comprehension_ty)elt); |
| } |
| break; |
| case GeneratorExp_kind: |
| marshal_write_int(buf, off, 7); |
| marshal_write_expr(buf, off, o->v.GeneratorExp.elt); |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.GeneratorExp.generators)); |
| for (i = 0; i < asdl_seq_LEN(o->v.GeneratorExp.generators); |
| i++) { |
| void *elt = asdl_seq_GET(o->v.GeneratorExp.generators, |
| i); |
| marshal_write_comprehension(buf, off, |
| (comprehension_ty)elt); |
| } |
| break; |
| case Yield_kind: |
| marshal_write_int(buf, off, 8); |
| if (o->v.Yield.value) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Yield.value); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case Compare_kind: |
| marshal_write_int(buf, off, 9); |
| marshal_write_expr(buf, off, o->v.Compare.left); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Compare.ops)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Compare.ops); i++) { |
| void *elt = asdl_seq_GET(o->v.Compare.ops, i); |
| marshal_write_cmpop(buf, off, (cmpop_ty)elt); |
| } |
| marshal_write_int(buf, off, |
| asdl_seq_LEN(o->v.Compare.comparators)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Compare.comparators); i++) { |
| void *elt = asdl_seq_GET(o->v.Compare.comparators, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| break; |
| case Call_kind: |
| marshal_write_int(buf, off, 10); |
| marshal_write_expr(buf, off, o->v.Call.func); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Call.args)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Call.args); i++) { |
| void *elt = asdl_seq_GET(o->v.Call.args, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Call.keywords)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Call.keywords); i++) { |
| void *elt = asdl_seq_GET(o->v.Call.keywords, i); |
| marshal_write_keyword(buf, off, (keyword_ty)elt); |
| } |
| if (o->v.Call.starargs) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Call.starargs); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Call.kwargs) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Call.kwargs); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case Repr_kind: |
| marshal_write_int(buf, off, 11); |
| marshal_write_expr(buf, off, o->v.Repr.value); |
| break; |
| case Num_kind: |
| marshal_write_int(buf, off, 12); |
| marshal_write_object(buf, off, o->v.Num.n); |
| break; |
| case Str_kind: |
| marshal_write_int(buf, off, 13); |
| marshal_write_string(buf, off, o->v.Str.s); |
| break; |
| case Attribute_kind: |
| marshal_write_int(buf, off, 14); |
| marshal_write_expr(buf, off, o->v.Attribute.value); |
| marshal_write_identifier(buf, off, o->v.Attribute.attr); |
| marshal_write_expr_context(buf, off, o->v.Attribute.ctx); |
| break; |
| case Subscript_kind: |
| marshal_write_int(buf, off, 15); |
| marshal_write_expr(buf, off, o->v.Subscript.value); |
| marshal_write_slice(buf, off, o->v.Subscript.slice); |
| marshal_write_expr_context(buf, off, o->v.Subscript.ctx); |
| break; |
| case Name_kind: |
| marshal_write_int(buf, off, 16); |
| marshal_write_identifier(buf, off, o->v.Name.id); |
| marshal_write_expr_context(buf, off, o->v.Name.ctx); |
| break; |
| case List_kind: |
| marshal_write_int(buf, off, 17); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.List.elts)); |
| for (i = 0; i < asdl_seq_LEN(o->v.List.elts); i++) { |
| void *elt = asdl_seq_GET(o->v.List.elts, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_expr_context(buf, off, o->v.List.ctx); |
| break; |
| case Tuple_kind: |
| marshal_write_int(buf, off, 18); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.Tuple.elts)); |
| for (i = 0; i < asdl_seq_LEN(o->v.Tuple.elts); i++) { |
| void *elt = asdl_seq_GET(o->v.Tuple.elts, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| marshal_write_expr_context(buf, off, o->v.Tuple.ctx); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_expr_context(PyObject **buf, int *off, expr_context_ty o) |
| { |
| int i; |
| switch (o) { |
| case Load: |
| marshal_write_int(buf, off, 1); |
| break; |
| case Store: |
| marshal_write_int(buf, off, 2); |
| break; |
| case Del: |
| marshal_write_int(buf, off, 3); |
| break; |
| case AugLoad: |
| marshal_write_int(buf, off, 4); |
| break; |
| case AugStore: |
| marshal_write_int(buf, off, 5); |
| break; |
| case Param: |
| marshal_write_int(buf, off, 6); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_slice(PyObject **buf, int *off, slice_ty o) |
| { |
| int i; |
| switch (o->kind) { |
| case Ellipsis_kind: |
| marshal_write_int(buf, off, 1); |
| break; |
| case Slice_kind: |
| marshal_write_int(buf, off, 2); |
| if (o->v.Slice.lower) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Slice.lower); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Slice.upper) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Slice.upper); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->v.Slice.step) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->v.Slice.step); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| break; |
| case ExtSlice_kind: |
| marshal_write_int(buf, off, 3); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->v.ExtSlice.dims)); |
| for (i = 0; i < asdl_seq_LEN(o->v.ExtSlice.dims); i++) { |
| void *elt = asdl_seq_GET(o->v.ExtSlice.dims, i); |
| marshal_write_slice(buf, off, (slice_ty)elt); |
| } |
| break; |
| case Index_kind: |
| marshal_write_int(buf, off, 4); |
| marshal_write_expr(buf, off, o->v.Index.value); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_boolop(PyObject **buf, int *off, boolop_ty o) |
| { |
| int i; |
| switch (o) { |
| case And: |
| marshal_write_int(buf, off, 1); |
| break; |
| case Or: |
| marshal_write_int(buf, off, 2); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_operator(PyObject **buf, int *off, operator_ty o) |
| { |
| int i; |
| switch (o) { |
| case Add: |
| marshal_write_int(buf, off, 1); |
| break; |
| case Sub: |
| marshal_write_int(buf, off, 2); |
| break; |
| case Mult: |
| marshal_write_int(buf, off, 3); |
| break; |
| case Div: |
| marshal_write_int(buf, off, 4); |
| break; |
| case Mod: |
| marshal_write_int(buf, off, 5); |
| break; |
| case Pow: |
| marshal_write_int(buf, off, 6); |
| break; |
| case LShift: |
| marshal_write_int(buf, off, 7); |
| break; |
| case RShift: |
| marshal_write_int(buf, off, 8); |
| break; |
| case BitOr: |
| marshal_write_int(buf, off, 9); |
| break; |
| case BitXor: |
| marshal_write_int(buf, off, 10); |
| break; |
| case BitAnd: |
| marshal_write_int(buf, off, 11); |
| break; |
| case FloorDiv: |
| marshal_write_int(buf, off, 12); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_unaryop(PyObject **buf, int *off, unaryop_ty o) |
| { |
| int i; |
| switch (o) { |
| case Invert: |
| marshal_write_int(buf, off, 1); |
| break; |
| case Not: |
| marshal_write_int(buf, off, 2); |
| break; |
| case UAdd: |
| marshal_write_int(buf, off, 3); |
| break; |
| case USub: |
| marshal_write_int(buf, off, 4); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_cmpop(PyObject **buf, int *off, cmpop_ty o) |
| { |
| int i; |
| switch (o) { |
| case Eq: |
| marshal_write_int(buf, off, 1); |
| break; |
| case NotEq: |
| marshal_write_int(buf, off, 2); |
| break; |
| case Lt: |
| marshal_write_int(buf, off, 3); |
| break; |
| case LtE: |
| marshal_write_int(buf, off, 4); |
| break; |
| case Gt: |
| marshal_write_int(buf, off, 5); |
| break; |
| case GtE: |
| marshal_write_int(buf, off, 6); |
| break; |
| case Is: |
| marshal_write_int(buf, off, 7); |
| break; |
| case IsNot: |
| marshal_write_int(buf, off, 8); |
| break; |
| case In: |
| marshal_write_int(buf, off, 9); |
| break; |
| case NotIn: |
| marshal_write_int(buf, off, 10); |
| break; |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_comprehension(PyObject **buf, int *off, comprehension_ty o) |
| { |
| int i; |
| marshal_write_expr(buf, off, o->target); |
| marshal_write_expr(buf, off, o->iter); |
| marshal_write_int(buf, off, asdl_seq_LEN(o->ifs)); |
| for (i = 0; i < asdl_seq_LEN(o->ifs); i++) { |
| void *elt = asdl_seq_GET(o->ifs, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_excepthandler(PyObject **buf, int *off, excepthandler_ty o) |
| { |
| int i; |
| if (o->type) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->type); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->name) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_expr(buf, off, o->name); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->body)); |
| for (i = 0; i < asdl_seq_LEN(o->body); i++) { |
| void *elt = asdl_seq_GET(o->body, i); |
| marshal_write_stmt(buf, off, (stmt_ty)elt); |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_arguments(PyObject **buf, int *off, arguments_ty o) |
| { |
| int i; |
| marshal_write_int(buf, off, asdl_seq_LEN(o->args)); |
| for (i = 0; i < asdl_seq_LEN(o->args); i++) { |
| void *elt = asdl_seq_GET(o->args, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| if (o->vararg) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_identifier(buf, off, o->vararg); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| if (o->kwarg) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_identifier(buf, off, o->kwarg); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| marshal_write_int(buf, off, asdl_seq_LEN(o->defaults)); |
| for (i = 0; i < asdl_seq_LEN(o->defaults); i++) { |
| void *elt = asdl_seq_GET(o->defaults, i); |
| marshal_write_expr(buf, off, (expr_ty)elt); |
| } |
| return 1; |
| } |
| |
| int |
| marshal_write_keyword(PyObject **buf, int *off, keyword_ty o) |
| { |
| int i; |
| marshal_write_identifier(buf, off, o->arg); |
| marshal_write_expr(buf, off, o->value); |
| return 1; |
| } |
| |
| int |
| marshal_write_alias(PyObject **buf, int *off, alias_ty o) |
| { |
| int i; |
| marshal_write_identifier(buf, off, o->name); |
| if (o->asname) { |
| marshal_write_int(buf, off, 1); |
| marshal_write_identifier(buf, off, o->asname); |
| } |
| else { |
| marshal_write_int(buf, off, 0); |
| } |
| return 1; |
| } |
| |