| /* File automatically generated by Parser/asdl_c.py */ |
| |
| #include "Python.h" |
| #include "Python-ast.h" |
| |
| PyTypeObject *mod_type; |
| static PyObject* ast2obj_mod(void*); |
| PyTypeObject *Module_type; |
| char *Module_fields[]={ |
| "body", |
| }; |
| PyTypeObject *Interactive_type; |
| char *Interactive_fields[]={ |
| "body", |
| }; |
| PyTypeObject *Expression_type; |
| char *Expression_fields[]={ |
| "body", |
| }; |
| PyTypeObject *Suite_type; |
| char *Suite_fields[]={ |
| "body", |
| }; |
| PyTypeObject *stmt_type; |
| static PyObject* ast2obj_stmt(void*); |
| PyTypeObject *FunctionDef_type; |
| char *FunctionDef_fields[]={ |
| "name", |
| "args", |
| "body", |
| "decorators", |
| }; |
| PyTypeObject *ClassDef_type; |
| char *ClassDef_fields[]={ |
| "name", |
| "bases", |
| "body", |
| }; |
| PyTypeObject *Return_type; |
| char *Return_fields[]={ |
| "value", |
| }; |
| PyTypeObject *Delete_type; |
| char *Delete_fields[]={ |
| "targets", |
| }; |
| PyTypeObject *Assign_type; |
| char *Assign_fields[]={ |
| "targets", |
| "value", |
| }; |
| PyTypeObject *AugAssign_type; |
| char *AugAssign_fields[]={ |
| "target", |
| "op", |
| "value", |
| }; |
| PyTypeObject *Print_type; |
| char *Print_fields[]={ |
| "dest", |
| "values", |
| "nl", |
| }; |
| PyTypeObject *For_type; |
| char *For_fields[]={ |
| "target", |
| "iter", |
| "body", |
| "orelse", |
| }; |
| PyTypeObject *While_type; |
| char *While_fields[]={ |
| "test", |
| "body", |
| "orelse", |
| }; |
| PyTypeObject *If_type; |
| char *If_fields[]={ |
| "test", |
| "body", |
| "orelse", |
| }; |
| PyTypeObject *Raise_type; |
| char *Raise_fields[]={ |
| "type", |
| "inst", |
| "tback", |
| }; |
| PyTypeObject *TryExcept_type; |
| char *TryExcept_fields[]={ |
| "body", |
| "handlers", |
| "orelse", |
| }; |
| PyTypeObject *TryFinally_type; |
| char *TryFinally_fields[]={ |
| "body", |
| "finalbody", |
| }; |
| PyTypeObject *Assert_type; |
| char *Assert_fields[]={ |
| "test", |
| "msg", |
| }; |
| PyTypeObject *Import_type; |
| char *Import_fields[]={ |
| "names", |
| }; |
| PyTypeObject *ImportFrom_type; |
| char *ImportFrom_fields[]={ |
| "module", |
| "names", |
| }; |
| PyTypeObject *Exec_type; |
| char *Exec_fields[]={ |
| "body", |
| "globals", |
| "locals", |
| }; |
| PyTypeObject *Global_type; |
| char *Global_fields[]={ |
| "names", |
| }; |
| PyTypeObject *Expr_type; |
| char *Expr_fields[]={ |
| "value", |
| }; |
| PyTypeObject *Pass_type; |
| PyTypeObject *Break_type; |
| PyTypeObject *Continue_type; |
| PyTypeObject *expr_type; |
| static PyObject* ast2obj_expr(void*); |
| PyTypeObject *BoolOp_type; |
| char *BoolOp_fields[]={ |
| "op", |
| "values", |
| }; |
| PyTypeObject *BinOp_type; |
| char *BinOp_fields[]={ |
| "left", |
| "op", |
| "right", |
| }; |
| PyTypeObject *UnaryOp_type; |
| char *UnaryOp_fields[]={ |
| "op", |
| "operand", |
| }; |
| PyTypeObject *Lambda_type; |
| char *Lambda_fields[]={ |
| "args", |
| "body", |
| }; |
| PyTypeObject *Dict_type; |
| char *Dict_fields[]={ |
| "keys", |
| "values", |
| }; |
| PyTypeObject *ListComp_type; |
| char *ListComp_fields[]={ |
| "elt", |
| "generators", |
| }; |
| PyTypeObject *GeneratorExp_type; |
| char *GeneratorExp_fields[]={ |
| "elt", |
| "generators", |
| }; |
| PyTypeObject *Yield_type; |
| char *Yield_fields[]={ |
| "value", |
| }; |
| PyTypeObject *Compare_type; |
| char *Compare_fields[]={ |
| "left", |
| "ops", |
| "comparators", |
| }; |
| PyTypeObject *Call_type; |
| char *Call_fields[]={ |
| "func", |
| "args", |
| "keywords", |
| "starargs", |
| "kwargs", |
| }; |
| PyTypeObject *Repr_type; |
| char *Repr_fields[]={ |
| "value", |
| }; |
| PyTypeObject *Num_type; |
| char *Num_fields[]={ |
| "n", |
| }; |
| PyTypeObject *Str_type; |
| char *Str_fields[]={ |
| "s", |
| }; |
| PyTypeObject *Attribute_type; |
| char *Attribute_fields[]={ |
| "value", |
| "attr", |
| "ctx", |
| }; |
| PyTypeObject *Subscript_type; |
| char *Subscript_fields[]={ |
| "value", |
| "slice", |
| "ctx", |
| }; |
| PyTypeObject *Name_type; |
| char *Name_fields[]={ |
| "id", |
| "ctx", |
| }; |
| PyTypeObject *List_type; |
| char *List_fields[]={ |
| "elts", |
| "ctx", |
| }; |
| PyTypeObject *Tuple_type; |
| char *Tuple_fields[]={ |
| "elts", |
| "ctx", |
| }; |
| PyTypeObject *expr_context_type; |
| static PyObject *Load_singleton, *Store_singleton, *Del_singleton, |
| *AugLoad_singleton, *AugStore_singleton, *Param_singleton; |
| static PyObject* ast2obj_expr_context(expr_context_ty); |
| PyTypeObject *Load_type; |
| PyTypeObject *Store_type; |
| PyTypeObject *Del_type; |
| PyTypeObject *AugLoad_type; |
| PyTypeObject *AugStore_type; |
| PyTypeObject *Param_type; |
| PyTypeObject *slice_type; |
| static PyObject* ast2obj_slice(void*); |
| PyTypeObject *Ellipsis_type; |
| PyTypeObject *Slice_type; |
| char *Slice_fields[]={ |
| "lower", |
| "upper", |
| "step", |
| }; |
| PyTypeObject *ExtSlice_type; |
| char *ExtSlice_fields[]={ |
| "dims", |
| }; |
| PyTypeObject *Index_type; |
| char *Index_fields[]={ |
| "value", |
| }; |
| PyTypeObject *boolop_type; |
| static PyObject *And_singleton, *Or_singleton; |
| static PyObject* ast2obj_boolop(boolop_ty); |
| PyTypeObject *And_type; |
| PyTypeObject *Or_type; |
| PyTypeObject *operator_type; |
| static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton, |
| *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton, |
| *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton, |
| *FloorDiv_singleton; |
| static PyObject* ast2obj_operator(operator_ty); |
| PyTypeObject *Add_type; |
| PyTypeObject *Sub_type; |
| PyTypeObject *Mult_type; |
| PyTypeObject *Div_type; |
| PyTypeObject *Mod_type; |
| PyTypeObject *Pow_type; |
| PyTypeObject *LShift_type; |
| PyTypeObject *RShift_type; |
| PyTypeObject *BitOr_type; |
| PyTypeObject *BitXor_type; |
| PyTypeObject *BitAnd_type; |
| PyTypeObject *FloorDiv_type; |
| PyTypeObject *unaryop_type; |
| static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton, |
| *USub_singleton; |
| static PyObject* ast2obj_unaryop(unaryop_ty); |
| PyTypeObject *Invert_type; |
| PyTypeObject *Not_type; |
| PyTypeObject *UAdd_type; |
| PyTypeObject *USub_type; |
| PyTypeObject *cmpop_type; |
| static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton, |
| *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton, |
| *NotIn_singleton; |
| static PyObject* ast2obj_cmpop(cmpop_ty); |
| PyTypeObject *Eq_type; |
| PyTypeObject *NotEq_type; |
| PyTypeObject *Lt_type; |
| PyTypeObject *LtE_type; |
| PyTypeObject *Gt_type; |
| PyTypeObject *GtE_type; |
| PyTypeObject *Is_type; |
| PyTypeObject *IsNot_type; |
| PyTypeObject *In_type; |
| PyTypeObject *NotIn_type; |
| PyTypeObject *comprehension_type; |
| static PyObject* ast2obj_comprehension(void*); |
| char *comprehension_fields[]={ |
| "target", |
| "iter", |
| "ifs", |
| }; |
| PyTypeObject *excepthandler_type; |
| static PyObject* ast2obj_excepthandler(void*); |
| char *excepthandler_fields[]={ |
| "type", |
| "name", |
| "body", |
| }; |
| PyTypeObject *arguments_type; |
| static PyObject* ast2obj_arguments(void*); |
| char *arguments_fields[]={ |
| "args", |
| "vararg", |
| "kwarg", |
| "defaults", |
| }; |
| PyTypeObject *keyword_type; |
| static PyObject* ast2obj_keyword(void*); |
| char *keyword_fields[]={ |
| "arg", |
| "value", |
| }; |
| PyTypeObject *alias_type; |
| static PyObject* ast2obj_alias(void*); |
| char *alias_fields[]={ |
| "name", |
| "asname", |
| }; |
| |
| |
| static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields) |
| { |
| PyObject *fnames, *result; |
| int i; |
| if (num_fields) { |
| fnames = PyTuple_New(num_fields); |
| if (!fnames) return NULL; |
| } else { |
| fnames = Py_None; |
| Py_INCREF(Py_None); |
| } |
| for(i=0; i < num_fields; i++) { |
| PyObject *field = PyString_FromString(fields[i]); |
| if (!field) { |
| Py_DECREF(fnames); |
| return NULL; |
| } |
| PyTuple_SET_ITEM(fnames, i, field); |
| } |
| result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sO}", type, base, "_fields", fnames); |
| Py_DECREF(fnames); |
| return (PyTypeObject*)result; |
| } |
| |
| static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*)) |
| { |
| int i, n = asdl_seq_LEN(seq); |
| PyObject *result = PyList_New(n); |
| PyObject *value; |
| if (!result) |
| return NULL; |
| for (i = 0; i < n; i++) { |
| value = func(asdl_seq_GET(seq, i)); |
| if (!value) { |
| Py_DECREF(result); |
| return NULL; |
| } |
| PyList_SET_ITEM(result, i, value); |
| } |
| return result; |
| } |
| |
| static PyObject* ast2obj_object(void *o) |
| { |
| if (!o) |
| o = Py_None; |
| Py_INCREF((PyObject*)o); |
| return (PyObject*)o; |
| } |
| #define ast2obj_identifier ast2obj_object |
| #define ast2obj_string ast2obj_object |
| static PyObject* ast2obj_bool(bool b) |
| { |
| return PyBool_FromLong(b); |
| } |
| |
| static int initialized; |
| static int init_types(void) |
| { |
| if (initialized) return 1; |
| mod_type = make_type("mod", &PyBaseObject_Type, NULL, 0); |
| Module_type = make_type("Module", mod_type, Module_fields, 1); |
| Interactive_type = make_type("Interactive", mod_type, |
| Interactive_fields, 1); |
| Expression_type = make_type("Expression", mod_type, Expression_fields, |
| 1); |
| Suite_type = make_type("Suite", mod_type, Suite_fields, 1); |
| stmt_type = make_type("stmt", &PyBaseObject_Type, NULL, 0); |
| FunctionDef_type = make_type("FunctionDef", stmt_type, |
| FunctionDef_fields, 4); |
| ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 3); |
| Return_type = make_type("Return", stmt_type, Return_fields, 1); |
| Delete_type = make_type("Delete", stmt_type, Delete_fields, 1); |
| Assign_type = make_type("Assign", stmt_type, Assign_fields, 2); |
| AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3); |
| Print_type = make_type("Print", stmt_type, Print_fields, 3); |
| For_type = make_type("For", stmt_type, For_fields, 4); |
| While_type = make_type("While", stmt_type, While_fields, 3); |
| If_type = make_type("If", stmt_type, If_fields, 3); |
| Raise_type = make_type("Raise", stmt_type, Raise_fields, 3); |
| TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3); |
| TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields, |
| 2); |
| Assert_type = make_type("Assert", stmt_type, Assert_fields, 2); |
| Import_type = make_type("Import", stmt_type, Import_fields, 1); |
| ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields, |
| 2); |
| Exec_type = make_type("Exec", stmt_type, Exec_fields, 3); |
| Global_type = make_type("Global", stmt_type, Global_fields, 1); |
| Expr_type = make_type("Expr", stmt_type, Expr_fields, 1); |
| Pass_type = make_type("Pass", stmt_type, NULL, 0); |
| Break_type = make_type("Break", stmt_type, NULL, 0); |
| Continue_type = make_type("Continue", stmt_type, NULL, 0); |
| expr_type = make_type("expr", &PyBaseObject_Type, NULL, 0); |
| BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2); |
| BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3); |
| UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2); |
| Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2); |
| Dict_type = make_type("Dict", expr_type, Dict_fields, 2); |
| ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2); |
| GeneratorExp_type = make_type("GeneratorExp", expr_type, |
| GeneratorExp_fields, 2); |
| Yield_type = make_type("Yield", expr_type, Yield_fields, 1); |
| Compare_type = make_type("Compare", expr_type, Compare_fields, 3); |
| Call_type = make_type("Call", expr_type, Call_fields, 5); |
| Repr_type = make_type("Repr", expr_type, Repr_fields, 1); |
| Num_type = make_type("Num", expr_type, Num_fields, 1); |
| Str_type = make_type("Str", expr_type, Str_fields, 1); |
| Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3); |
| Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3); |
| Name_type = make_type("Name", expr_type, Name_fields, 2); |
| List_type = make_type("List", expr_type, List_fields, 2); |
| Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2); |
| expr_context_type = make_type("expr_context", &PyBaseObject_Type, NULL, |
| 0); |
| Load_type = make_type("Load", expr_context_type, NULL, 0); |
| Load_singleton = PyType_GenericNew(Load_type, NULL, NULL); |
| Store_type = make_type("Store", expr_context_type, NULL, 0); |
| Store_singleton = PyType_GenericNew(Store_type, NULL, NULL); |
| Del_type = make_type("Del", expr_context_type, NULL, 0); |
| Del_singleton = PyType_GenericNew(Del_type, NULL, NULL); |
| AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0); |
| AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL); |
| AugStore_type = make_type("AugStore", expr_context_type, NULL, 0); |
| AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL); |
| Param_type = make_type("Param", expr_context_type, NULL, 0); |
| Param_singleton = PyType_GenericNew(Param_type, NULL, NULL); |
| slice_type = make_type("slice", &PyBaseObject_Type, NULL, 0); |
| Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0); |
| Slice_type = make_type("Slice", slice_type, Slice_fields, 3); |
| ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1); |
| Index_type = make_type("Index", slice_type, Index_fields, 1); |
| boolop_type = make_type("boolop", &PyBaseObject_Type, NULL, 0); |
| And_type = make_type("And", boolop_type, NULL, 0); |
| And_singleton = PyType_GenericNew(And_type, NULL, NULL); |
| Or_type = make_type("Or", boolop_type, NULL, 0); |
| Or_singleton = PyType_GenericNew(Or_type, NULL, NULL); |
| operator_type = make_type("operator", &PyBaseObject_Type, NULL, 0); |
| Add_type = make_type("Add", operator_type, NULL, 0); |
| Add_singleton = PyType_GenericNew(Add_type, NULL, NULL); |
| Sub_type = make_type("Sub", operator_type, NULL, 0); |
| Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL); |
| Mult_type = make_type("Mult", operator_type, NULL, 0); |
| Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL); |
| Div_type = make_type("Div", operator_type, NULL, 0); |
| Div_singleton = PyType_GenericNew(Div_type, NULL, NULL); |
| Mod_type = make_type("Mod", operator_type, NULL, 0); |
| Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL); |
| Pow_type = make_type("Pow", operator_type, NULL, 0); |
| Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL); |
| LShift_type = make_type("LShift", operator_type, NULL, 0); |
| LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL); |
| RShift_type = make_type("RShift", operator_type, NULL, 0); |
| RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL); |
| BitOr_type = make_type("BitOr", operator_type, NULL, 0); |
| BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL); |
| BitXor_type = make_type("BitXor", operator_type, NULL, 0); |
| BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL); |
| BitAnd_type = make_type("BitAnd", operator_type, NULL, 0); |
| BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL); |
| FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0); |
| FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL); |
| unaryop_type = make_type("unaryop", &PyBaseObject_Type, NULL, 0); |
| Invert_type = make_type("Invert", unaryop_type, NULL, 0); |
| Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL); |
| Not_type = make_type("Not", unaryop_type, NULL, 0); |
| Not_singleton = PyType_GenericNew(Not_type, NULL, NULL); |
| UAdd_type = make_type("UAdd", unaryop_type, NULL, 0); |
| UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL); |
| USub_type = make_type("USub", unaryop_type, NULL, 0); |
| USub_singleton = PyType_GenericNew(USub_type, NULL, NULL); |
| cmpop_type = make_type("cmpop", &PyBaseObject_Type, NULL, 0); |
| Eq_type = make_type("Eq", cmpop_type, NULL, 0); |
| Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL); |
| NotEq_type = make_type("NotEq", cmpop_type, NULL, 0); |
| NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL); |
| Lt_type = make_type("Lt", cmpop_type, NULL, 0); |
| Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL); |
| LtE_type = make_type("LtE", cmpop_type, NULL, 0); |
| LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL); |
| Gt_type = make_type("Gt", cmpop_type, NULL, 0); |
| Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL); |
| GtE_type = make_type("GtE", cmpop_type, NULL, 0); |
| GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL); |
| Is_type = make_type("Is", cmpop_type, NULL, 0); |
| Is_singleton = PyType_GenericNew(Is_type, NULL, NULL); |
| IsNot_type = make_type("IsNot", cmpop_type, NULL, 0); |
| IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL); |
| In_type = make_type("In", cmpop_type, NULL, 0); |
| In_singleton = PyType_GenericNew(In_type, NULL, NULL); |
| NotIn_type = make_type("NotIn", cmpop_type, NULL, 0); |
| NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL); |
| comprehension_type = make_type("comprehension", &PyBaseObject_Type, |
| comprehension_fields, 3); |
| excepthandler_type = make_type("excepthandler", &PyBaseObject_Type, |
| excepthandler_fields, 3); |
| arguments_type = make_type("arguments", &PyBaseObject_Type, |
| arguments_fields, 4); |
| keyword_type = make_type("keyword", &PyBaseObject_Type, keyword_fields, |
| 2); |
| alias_type = make_type("alias", &PyBaseObject_Type, alias_fields, 2); |
| return 1; |
| } |
| |
| mod_ty |
| Module(asdl_seq * body, PyArena *arena) |
| { |
| mod_ty p; |
| p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Module_kind; |
| p->v.Module.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Interactive(asdl_seq * body, PyArena *arena) |
| { |
| mod_ty p; |
| p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Interactive_kind; |
| p->v.Interactive.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Expression(expr_ty body, PyArena *arena) |
| { |
| mod_ty p; |
| if (!body) { |
| PyErr_SetString(PyExc_ValueError, |
| "field body is required for Expression"); |
| return NULL; |
| } |
| p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Expression_kind; |
| p->v.Expression.body = body; |
| return p; |
| } |
| |
| mod_ty |
| Suite(asdl_seq * body, PyArena *arena) |
| { |
| mod_ty p; |
| p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, |
| PyArena *arena) |
| { |
| stmt_ty p; |
| if (!name) { |
| PyErr_SetString(PyExc_ValueError, |
| "field name is required for ClassDef"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Return_kind; |
| p->v.Return.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Delete(asdl_seq * targets, int lineno, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Assign"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena |
| *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena |
| *arena) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for While"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for If"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, |
| PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!test) { |
| PyErr_SetString(PyExc_ValueError, |
| "field test is required for Assert"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!module) { |
| PyErr_SetString(PyExc_ValueError, |
| "field module is required for ImportFrom"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!body) { |
| PyErr_SetString(PyExc_ValueError, |
| "field body is required for Exec"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Global_kind; |
| p->v.Global.names = names; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Expr(expr_ty value, int lineno, PyArena *arena) |
| { |
| stmt_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Expr"); |
| return NULL; |
| } |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Expr_kind; |
| p->v.Expr.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Pass(int lineno, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Pass_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Break(int lineno, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Break_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| stmt_ty |
| Continue(int lineno, PyArena *arena) |
| { |
| stmt_ty p; |
| p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Continue_kind; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| BoolOp(boolop_ty op, asdl_seq * values, int lineno, PyArena *arena) |
| { |
| expr_ty p; |
| if (!op) { |
| PyErr_SetString(PyExc_ValueError, |
| "field op is required for BoolOp"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!elt) { |
| PyErr_SetString(PyExc_ValueError, |
| "field elt is required for ListComp"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!elt) { |
| PyErr_SetString(PyExc_ValueError, |
| "field elt is required for GeneratorExp"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, |
| PyArena *arena) |
| { |
| expr_ty p; |
| if (!left) { |
| PyErr_SetString(PyExc_ValueError, |
| "field left is required for Compare"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!func) { |
| PyErr_SetString(PyExc_ValueError, |
| "field func is required for Call"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Repr"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Repr_kind; |
| p->v.Repr.value = value; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Num(object n, int lineno, PyArena *arena) |
| { |
| expr_ty p; |
| if (!n) { |
| PyErr_SetString(PyExc_ValueError, |
| "field n is required for Num"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Num_kind; |
| p->v.Num.n = n; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| expr_ty |
| Str(string s, int lineno, PyArena *arena) |
| { |
| expr_ty p; |
| if (!s) { |
| PyErr_SetString(PyExc_ValueError, |
| "field s is required for Str"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, |
| PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, |
| PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for List"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| expr_ty p; |
| if (!ctx) { |
| PyErr_SetString(PyExc_ValueError, |
| "field ctx is required for Tuple"); |
| return NULL; |
| } |
| p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Tuple_kind; |
| p->v.Tuple.elts = elts; |
| p->v.Tuple.ctx = ctx; |
| p->lineno = lineno; |
| return p; |
| } |
| |
| slice_ty |
| Ellipsis(PyArena *arena) |
| { |
| slice_ty p; |
| p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = Ellipsis_kind; |
| return p; |
| } |
| |
| slice_ty |
| Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena) |
| { |
| slice_ty p; |
| p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| slice_ty p; |
| p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->kind = ExtSlice_kind; |
| p->v.ExtSlice.dims = dims; |
| return p; |
| } |
| |
| slice_ty |
| Index(expr_ty value, PyArena *arena) |
| { |
| slice_ty p; |
| if (!value) { |
| PyErr_SetString(PyExc_ValueError, |
| "field value is required for Index"); |
| return NULL; |
| } |
| p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| excepthandler_ty p; |
| p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| 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, PyArena *arena) |
| { |
| arguments_ty p; |
| p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->args = args; |
| p->vararg = vararg; |
| p->kwarg = kwarg; |
| p->defaults = defaults; |
| return p; |
| } |
| |
| keyword_ty |
| keyword(identifier arg, expr_ty value, PyArena *arena) |
| { |
| 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)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->arg = arg; |
| p->value = value; |
| return p; |
| } |
| |
| alias_ty |
| alias(identifier name, identifier asname, PyArena *arena) |
| { |
| alias_ty p; |
| if (!name) { |
| PyErr_SetString(PyExc_ValueError, |
| "field name is required for alias"); |
| return NULL; |
| } |
| p = (alias_ty)PyArena_Malloc(arena, sizeof(*p)); |
| if (!p) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| p->name = name; |
| p->asname = asname; |
| return p; |
| } |
| |
| |
| PyObject* |
| ast2obj_mod(void* _o) |
| { |
| mod_ty o = (mod_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| switch (o->kind) { |
| case Module_kind: |
| result = PyType_GenericNew(Module_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Module.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Interactive_kind: |
| result = PyType_GenericNew(Interactive_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Expression_kind: |
| result = PyType_GenericNew(Expression_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Expression.body); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Suite_kind: |
| result = PyType_GenericNew(Suite_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Suite.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| } |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_stmt(void* _o) |
| { |
| stmt_ty o = (stmt_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| switch (o->kind) { |
| case FunctionDef_kind: |
| result = PyType_GenericNew(FunctionDef_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_identifier(o->v.FunctionDef.name); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "name", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_arguments(o->v.FunctionDef.args); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "args", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.FunctionDef.decorators, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "decorators", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case ClassDef_kind: |
| result = PyType_GenericNew(ClassDef_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_identifier(o->v.ClassDef.name); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "name", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "bases", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Return_kind: |
| result = PyType_GenericNew(Return_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Return.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Delete_kind: |
| result = PyType_GenericNew(Delete_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Delete.targets, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "targets", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Assign_kind: |
| result = PyType_GenericNew(Assign_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Assign.targets, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "targets", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Assign.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case AugAssign_kind: |
| result = PyType_GenericNew(AugAssign_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.AugAssign.target); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "target", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_operator(o->v.AugAssign.op); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "op", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.AugAssign.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Print_kind: |
| result = PyType_GenericNew(Print_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Print.dest); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "dest", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.Print.values, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "values", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_bool(o->v.Print.nl); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "nl", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case For_kind: |
| result = PyType_GenericNew(For_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.For.target); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "target", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.For.iter); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "iter", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.For.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.For.orelse, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "orelse", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case While_kind: |
| result = PyType_GenericNew(While_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.While.test); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "test", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.While.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.While.orelse, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "orelse", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case If_kind: |
| result = PyType_GenericNew(If_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.If.test); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "test", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.If.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.If.orelse, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "orelse", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Raise_kind: |
| result = PyType_GenericNew(Raise_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Raise.type); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "type", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Raise.inst); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "inst", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Raise.tback); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "tback", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case TryExcept_kind: |
| result = PyType_GenericNew(TryExcept_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.TryExcept.handlers, |
| ast2obj_excepthandler); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "handlers", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "orelse", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case TryFinally_kind: |
| result = PyType_GenericNew(TryFinally_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "finalbody", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Assert_kind: |
| result = PyType_GenericNew(Assert_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Assert.test); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "test", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Assert.msg); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "msg", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Import_kind: |
| result = PyType_GenericNew(Import_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Import.names, ast2obj_alias); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "names", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case ImportFrom_kind: |
| result = PyType_GenericNew(ImportFrom_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_identifier(o->v.ImportFrom.module); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "module", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "names", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Exec_kind: |
| result = PyType_GenericNew(Exec_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Exec.body); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Exec.globals); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "globals", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Exec.locals); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "locals", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Global_kind: |
| result = PyType_GenericNew(Global_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Global.names, ast2obj_identifier); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "names", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Expr_kind: |
| result = PyType_GenericNew(Expr_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Expr.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Pass_kind: |
| result = PyType_GenericNew(Pass_type, NULL, NULL); |
| if (!result) goto failed; |
| break; |
| case Break_kind: |
| result = PyType_GenericNew(Break_type, NULL, NULL); |
| if (!result) goto failed; |
| break; |
| case Continue_kind: |
| result = PyType_GenericNew(Continue_type, NULL, NULL); |
| if (!result) goto failed; |
| break; |
| } |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_expr(void* _o) |
| { |
| expr_ty o = (expr_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| switch (o->kind) { |
| case BoolOp_kind: |
| result = PyType_GenericNew(BoolOp_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_boolop(o->v.BoolOp.op); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "op", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "values", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case BinOp_kind: |
| result = PyType_GenericNew(BinOp_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.BinOp.left); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "left", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_operator(o->v.BinOp.op); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "op", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.BinOp.right); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "right", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case UnaryOp_kind: |
| result = PyType_GenericNew(UnaryOp_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_unaryop(o->v.UnaryOp.op); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "op", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.UnaryOp.operand); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "operand", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Lambda_kind: |
| result = PyType_GenericNew(Lambda_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_arguments(o->v.Lambda.args); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "args", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Lambda.body); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Dict_kind: |
| result = PyType_GenericNew(Dict_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Dict.keys, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "keys", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.Dict.values, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "values", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case ListComp_kind: |
| result = PyType_GenericNew(ListComp_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.ListComp.elt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "elt", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.ListComp.generators, |
| ast2obj_comprehension); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "generators", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case GeneratorExp_kind: |
| result = PyType_GenericNew(GeneratorExp_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.GeneratorExp.elt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "elt", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.GeneratorExp.generators, |
| ast2obj_comprehension); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "generators", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Yield_kind: |
| result = PyType_GenericNew(Yield_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Yield.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Compare_kind: |
| result = PyType_GenericNew(Compare_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Compare.left); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "left", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| { |
| int i, n = asdl_seq_LEN(o->v.Compare.ops); |
| value = PyList_New(n); |
| if (!value) goto failed; |
| for(i = 0; i < n; i++) |
| PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i))); |
| } |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ops", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "comparators", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Call_kind: |
| result = PyType_GenericNew(Call_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Call.func); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "func", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.Call.args, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "args", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "keywords", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Call.starargs); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "starargs", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Call.kwargs); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "kwargs", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Repr_kind: |
| result = PyType_GenericNew(Repr_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Repr.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Num_kind: |
| result = PyType_GenericNew(Num_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_object(o->v.Num.n); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "n", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Str_kind: |
| result = PyType_GenericNew(Str_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_string(o->v.Str.s); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "s", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Attribute_kind: |
| result = PyType_GenericNew(Attribute_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Attribute.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_identifier(o->v.Attribute.attr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "attr", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr_context(o->v.Attribute.ctx); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ctx", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Subscript_kind: |
| result = PyType_GenericNew(Subscript_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Subscript.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_slice(o->v.Subscript.slice); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "slice", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr_context(o->v.Subscript.ctx); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ctx", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Name_kind: |
| result = PyType_GenericNew(Name_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_identifier(o->v.Name.id); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "id", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr_context(o->v.Name.ctx); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ctx", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case List_kind: |
| result = PyType_GenericNew(List_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.List.elts, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "elts", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr_context(o->v.List.ctx); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ctx", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Tuple_kind: |
| result = PyType_GenericNew(Tuple_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "elts", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr_context(o->v.Tuple.ctx); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ctx", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| } |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* ast2obj_expr_context(expr_context_ty o) |
| { |
| switch(o) { |
| case Load: |
| Py_INCREF(Load_singleton); |
| return Load_singleton; |
| case Store: |
| Py_INCREF(Store_singleton); |
| return Store_singleton; |
| case Del: |
| Py_INCREF(Del_singleton); |
| return Del_singleton; |
| case AugLoad: |
| Py_INCREF(AugLoad_singleton); |
| return AugLoad_singleton; |
| case AugStore: |
| Py_INCREF(AugStore_singleton); |
| return AugStore_singleton; |
| case Param: |
| Py_INCREF(Param_singleton); |
| return Param_singleton; |
| } |
| return NULL; /* cannot happen */ |
| } |
| PyObject* |
| ast2obj_slice(void* _o) |
| { |
| slice_ty o = (slice_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| switch (o->kind) { |
| case Ellipsis_kind: |
| result = PyType_GenericNew(Ellipsis_type, NULL, NULL); |
| if (!result) goto failed; |
| break; |
| case Slice_kind: |
| result = PyType_GenericNew(Slice_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Slice.lower); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "lower", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Slice.upper); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "upper", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->v.Slice.step); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "step", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case ExtSlice_kind: |
| result = PyType_GenericNew(ExtSlice_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "dims", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| case Index_kind: |
| result = PyType_GenericNew(Index_type, NULL, NULL); |
| if (!result) goto failed; |
| value = ast2obj_expr(o->v.Index.value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| break; |
| } |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* ast2obj_boolop(boolop_ty o) |
| { |
| switch(o) { |
| case And: |
| Py_INCREF(And_singleton); |
| return And_singleton; |
| case Or: |
| Py_INCREF(Or_singleton); |
| return Or_singleton; |
| } |
| return NULL; /* cannot happen */ |
| } |
| PyObject* ast2obj_operator(operator_ty o) |
| { |
| switch(o) { |
| case Add: |
| Py_INCREF(Add_singleton); |
| return Add_singleton; |
| case Sub: |
| Py_INCREF(Sub_singleton); |
| return Sub_singleton; |
| case Mult: |
| Py_INCREF(Mult_singleton); |
| return Mult_singleton; |
| case Div: |
| Py_INCREF(Div_singleton); |
| return Div_singleton; |
| case Mod: |
| Py_INCREF(Mod_singleton); |
| return Mod_singleton; |
| case Pow: |
| Py_INCREF(Pow_singleton); |
| return Pow_singleton; |
| case LShift: |
| Py_INCREF(LShift_singleton); |
| return LShift_singleton; |
| case RShift: |
| Py_INCREF(RShift_singleton); |
| return RShift_singleton; |
| case BitOr: |
| Py_INCREF(BitOr_singleton); |
| return BitOr_singleton; |
| case BitXor: |
| Py_INCREF(BitXor_singleton); |
| return BitXor_singleton; |
| case BitAnd: |
| Py_INCREF(BitAnd_singleton); |
| return BitAnd_singleton; |
| case FloorDiv: |
| Py_INCREF(FloorDiv_singleton); |
| return FloorDiv_singleton; |
| } |
| return NULL; /* cannot happen */ |
| } |
| PyObject* ast2obj_unaryop(unaryop_ty o) |
| { |
| switch(o) { |
| case Invert: |
| Py_INCREF(Invert_singleton); |
| return Invert_singleton; |
| case Not: |
| Py_INCREF(Not_singleton); |
| return Not_singleton; |
| case UAdd: |
| Py_INCREF(UAdd_singleton); |
| return UAdd_singleton; |
| case USub: |
| Py_INCREF(USub_singleton); |
| return USub_singleton; |
| } |
| return NULL; /* cannot happen */ |
| } |
| PyObject* ast2obj_cmpop(cmpop_ty o) |
| { |
| switch(o) { |
| case Eq: |
| Py_INCREF(Eq_singleton); |
| return Eq_singleton; |
| case NotEq: |
| Py_INCREF(NotEq_singleton); |
| return NotEq_singleton; |
| case Lt: |
| Py_INCREF(Lt_singleton); |
| return Lt_singleton; |
| case LtE: |
| Py_INCREF(LtE_singleton); |
| return LtE_singleton; |
| case Gt: |
| Py_INCREF(Gt_singleton); |
| return Gt_singleton; |
| case GtE: |
| Py_INCREF(GtE_singleton); |
| return GtE_singleton; |
| case Is: |
| Py_INCREF(Is_singleton); |
| return Is_singleton; |
| case IsNot: |
| Py_INCREF(IsNot_singleton); |
| return IsNot_singleton; |
| case In: |
| Py_INCREF(In_singleton); |
| return In_singleton; |
| case NotIn: |
| Py_INCREF(NotIn_singleton); |
| return NotIn_singleton; |
| } |
| return NULL; /* cannot happen */ |
| } |
| PyObject* |
| ast2obj_comprehension(void* _o) |
| { |
| comprehension_ty o = (comprehension_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| result = PyType_GenericNew(comprehension_type, NULL, NULL); |
| if (!result) return NULL; |
| value = ast2obj_expr(o->target); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "target", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->iter); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "iter", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->ifs, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "ifs", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_excepthandler(void* _o) |
| { |
| excepthandler_ty o = (excepthandler_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| result = PyType_GenericNew(excepthandler_type, NULL, NULL); |
| if (!result) return NULL; |
| value = ast2obj_expr(o->type); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "type", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->name); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "name", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->body, ast2obj_stmt); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "body", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_arguments(void* _o) |
| { |
| arguments_ty o = (arguments_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| result = PyType_GenericNew(arguments_type, NULL, NULL); |
| if (!result) return NULL; |
| value = ast2obj_list(o->args, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "args", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_identifier(o->vararg); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "vararg", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_identifier(o->kwarg); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "kwarg", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_list(o->defaults, ast2obj_expr); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "defaults", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_keyword(void* _o) |
| { |
| keyword_ty o = (keyword_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| result = PyType_GenericNew(keyword_type, NULL, NULL); |
| if (!result) return NULL; |
| value = ast2obj_identifier(o->arg); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "arg", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_expr(o->value); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "value", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| PyObject* |
| ast2obj_alias(void* _o) |
| { |
| alias_ty o = (alias_ty)_o; |
| PyObject *result = NULL, *value = NULL; |
| if (!o) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| result = PyType_GenericNew(alias_type, NULL, NULL); |
| if (!result) return NULL; |
| value = ast2obj_identifier(o->name); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "name", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| value = ast2obj_identifier(o->asname); |
| if (!value) goto failed; |
| if (PyObject_SetAttrString(result, "asname", value) == -1) |
| goto failed; |
| Py_DECREF(value); |
| |
| return result; |
| failed: |
| Py_XDECREF(value); |
| Py_XDECREF(result); |
| return NULL; |
| } |
| |
| |
| |
| PyObject* PyAST_mod2obj(mod_ty t) |
| { |
| init_types(); |
| return ast2obj_mod(t); |
| } |
| |
| |