Blame - Python/Python-ast.c - platform/external/python/cpython2

blob: cf2712918394885c14153626e4d60bd616b2c2d8 [file] [log] [blame]

Neal Norwitz	897ff81	2005-12-11 21:18:22 +0000	[diff] [blame]	1	/* File automatically generated by Parser/asdl_c.py */
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2
				3	#include "Python.h"
				4	#include "Python-ast.h"
				5
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	6	PyTypeObject *mod_type;
				7	static PyObject* ast2obj_mod(void*);
				8	PyTypeObject *Module_type;
				9	char *Module_fields[]={
				10	"body",
				11	};
				12	PyTypeObject *Interactive_type;
				13	char *Interactive_fields[]={
				14	"body",
				15	};
				16	PyTypeObject *Expression_type;
				17	char *Expression_fields[]={
				18	"body",
				19	};
				20	PyTypeObject *Suite_type;
				21	char *Suite_fields[]={
				22	"body",
				23	};
				24	PyTypeObject *stmt_type;
				25	static PyObject* ast2obj_stmt(void*);
				26	PyTypeObject *FunctionDef_type;
				27	char *FunctionDef_fields[]={
				28	"name",
				29	"args",
				30	"body",
				31	"decorators",
				32	};
				33	PyTypeObject *ClassDef_type;
				34	char *ClassDef_fields[]={
				35	"name",
				36	"bases",
				37	"body",
				38	};
				39	PyTypeObject *Return_type;
				40	char *Return_fields[]={
				41	"value",
				42	};
				43	PyTypeObject *Delete_type;
				44	char *Delete_fields[]={
				45	"targets",
				46	};
				47	PyTypeObject *Assign_type;
				48	char *Assign_fields[]={
				49	"targets",
				50	"value",
				51	};
				52	PyTypeObject *AugAssign_type;
				53	char *AugAssign_fields[]={
				54	"target",
				55	"op",
				56	"value",
				57	};
				58	PyTypeObject *Print_type;
				59	char *Print_fields[]={
				60	"dest",
				61	"values",
				62	"nl",
				63	};
				64	PyTypeObject *For_type;
				65	char *For_fields[]={
				66	"target",
				67	"iter",
				68	"body",
				69	"orelse",
				70	};
				71	PyTypeObject *While_type;
				72	char *While_fields[]={
				73	"test",
				74	"body",
				75	"orelse",
				76	};
				77	PyTypeObject *If_type;
				78	char *If_fields[]={
				79	"test",
				80	"body",
				81	"orelse",
				82	};
				83	PyTypeObject *Raise_type;
				84	char *Raise_fields[]={
				85	"type",
				86	"inst",
				87	"tback",
				88	};
				89	PyTypeObject *TryExcept_type;
				90	char *TryExcept_fields[]={
				91	"body",
				92	"handlers",
				93	"orelse",
				94	};
				95	PyTypeObject *TryFinally_type;
				96	char *TryFinally_fields[]={
				97	"body",
				98	"finalbody",
				99	};
				100	PyTypeObject *Assert_type;
				101	char *Assert_fields[]={
				102	"test",
				103	"msg",
				104	};
				105	PyTypeObject *Import_type;
				106	char *Import_fields[]={
				107	"names",
				108	};
				109	PyTypeObject *ImportFrom_type;
				110	char *ImportFrom_fields[]={
				111	"module",
				112	"names",
				113	};
				114	PyTypeObject *Exec_type;
				115	char *Exec_fields[]={
				116	"body",
				117	"globals",
				118	"locals",
				119	};
				120	PyTypeObject *Global_type;
				121	char *Global_fields[]={
				122	"names",
				123	};
				124	PyTypeObject *Expr_type;
				125	char *Expr_fields[]={
				126	"value",
				127	};
				128	PyTypeObject *Pass_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	129	PyTypeObject *Break_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	130	PyTypeObject *Continue_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	131	PyTypeObject *expr_type;
				132	static PyObject* ast2obj_expr(void*);
				133	PyTypeObject *BoolOp_type;
				134	char *BoolOp_fields[]={
				135	"op",
				136	"values",
				137	};
				138	PyTypeObject *BinOp_type;
				139	char *BinOp_fields[]={
				140	"left",
				141	"op",
				142	"right",
				143	};
				144	PyTypeObject *UnaryOp_type;
				145	char *UnaryOp_fields[]={
				146	"op",
				147	"operand",
				148	};
				149	PyTypeObject *Lambda_type;
				150	char *Lambda_fields[]={
				151	"args",
				152	"body",
				153	};
				154	PyTypeObject *Dict_type;
				155	char *Dict_fields[]={
				156	"keys",
				157	"values",
				158	};
				159	PyTypeObject *ListComp_type;
				160	char *ListComp_fields[]={
				161	"elt",
				162	"generators",
				163	};
				164	PyTypeObject *GeneratorExp_type;
				165	char *GeneratorExp_fields[]={
				166	"elt",
				167	"generators",
				168	};
				169	PyTypeObject *Yield_type;
				170	char *Yield_fields[]={
				171	"value",
				172	};
				173	PyTypeObject *Compare_type;
				174	char *Compare_fields[]={
				175	"left",
				176	"ops",
				177	"comparators",
				178	};
				179	PyTypeObject *Call_type;
				180	char *Call_fields[]={
				181	"func",
				182	"args",
				183	"keywords",
				184	"starargs",
				185	"kwargs",
				186	};
				187	PyTypeObject *Repr_type;
				188	char *Repr_fields[]={
				189	"value",
				190	};
				191	PyTypeObject *Num_type;
				192	char *Num_fields[]={
				193	"n",
				194	};
				195	PyTypeObject *Str_type;
				196	char *Str_fields[]={
				197	"s",
				198	};
				199	PyTypeObject *Attribute_type;
				200	char *Attribute_fields[]={
				201	"value",
				202	"attr",
				203	"ctx",
				204	};
				205	PyTypeObject *Subscript_type;
				206	char *Subscript_fields[]={
				207	"value",
				208	"slice",
				209	"ctx",
				210	};
				211	PyTypeObject *Name_type;
				212	char *Name_fields[]={
				213	"id",
				214	"ctx",
				215	};
				216	PyTypeObject *List_type;
				217	char *List_fields[]={
				218	"elts",
				219	"ctx",
				220	};
				221	PyTypeObject *Tuple_type;
				222	char *Tuple_fields[]={
				223	"elts",
				224	"ctx",
				225	};
				226	PyTypeObject *expr_context_type;
				227	static PyObject Load_singleton, Store_singleton, *Del_singleton,
				228	AugLoad_singleton, AugStore_singleton, *Param_singleton;
				229	static PyObject* ast2obj_expr_context(expr_context_ty);
				230	PyTypeObject *Load_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	231	PyTypeObject *Store_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	232	PyTypeObject *Del_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	233	PyTypeObject *AugLoad_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	234	PyTypeObject *AugStore_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	235	PyTypeObject *Param_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	236	PyTypeObject *slice_type;
				237	static PyObject* ast2obj_slice(void*);
				238	PyTypeObject *Ellipsis_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	239	PyTypeObject *Slice_type;
				240	char *Slice_fields[]={
				241	"lower",
				242	"upper",
				243	"step",
				244	};
				245	PyTypeObject *ExtSlice_type;
				246	char *ExtSlice_fields[]={
				247	"dims",
				248	};
				249	PyTypeObject *Index_type;
				250	char *Index_fields[]={
				251	"value",
				252	};
				253	PyTypeObject *boolop_type;
				254	static PyObject And_singleton, Or_singleton;
				255	static PyObject* ast2obj_boolop(boolop_ty);
				256	PyTypeObject *And_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	257	PyTypeObject *Or_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	258	PyTypeObject *operator_type;
				259	static PyObject Add_singleton, Sub_singleton, *Mult_singleton,
				260	Div_singleton, Mod_singleton, Pow_singleton, LShift_singleton,
				261	RShift_singleton, BitOr_singleton, BitXor_singleton, BitAnd_singleton,
				262	*FloorDiv_singleton;
				263	static PyObject* ast2obj_operator(operator_ty);
				264	PyTypeObject *Add_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	265	PyTypeObject *Sub_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	266	PyTypeObject *Mult_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	267	PyTypeObject *Div_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	268	PyTypeObject *Mod_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	269	PyTypeObject *Pow_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	270	PyTypeObject *LShift_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	271	PyTypeObject *RShift_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	272	PyTypeObject *BitOr_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	273	PyTypeObject *BitXor_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	274	PyTypeObject *BitAnd_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	275	PyTypeObject *FloorDiv_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	276	PyTypeObject *unaryop_type;
				277	static PyObject Invert_singleton, Not_singleton, *UAdd_singleton,
				278	*USub_singleton;
				279	static PyObject* ast2obj_unaryop(unaryop_ty);
				280	PyTypeObject *Invert_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	281	PyTypeObject *Not_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	282	PyTypeObject *UAdd_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	283	PyTypeObject *USub_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	284	PyTypeObject *cmpop_type;
				285	static PyObject Eq_singleton, NotEq_singleton, Lt_singleton, LtE_singleton,
				286	Gt_singleton, GtE_singleton, Is_singleton, IsNot_singleton, *In_singleton,
				287	*NotIn_singleton;
				288	static PyObject* ast2obj_cmpop(cmpop_ty);
				289	PyTypeObject *Eq_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	290	PyTypeObject *NotEq_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	291	PyTypeObject *Lt_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	292	PyTypeObject *LtE_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	293	PyTypeObject *Gt_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	294	PyTypeObject *GtE_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	295	PyTypeObject *Is_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	296	PyTypeObject *IsNot_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	297	PyTypeObject *In_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	298	PyTypeObject *NotIn_type;
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	299	PyTypeObject *comprehension_type;
				300	static PyObject* ast2obj_comprehension(void*);
				301	char *comprehension_fields[]={
				302	"target",
				303	"iter",
				304	"ifs",
				305	};
				306	PyTypeObject *excepthandler_type;
				307	static PyObject* ast2obj_excepthandler(void*);
				308	char *excepthandler_fields[]={
				309	"type",
				310	"name",
				311	"body",
				312	};
				313	PyTypeObject *arguments_type;
				314	static PyObject* ast2obj_arguments(void*);
				315	char *arguments_fields[]={
				316	"args",
				317	"vararg",
				318	"kwarg",
				319	"defaults",
				320	};
				321	PyTypeObject *keyword_type;
				322	static PyObject* ast2obj_keyword(void*);
				323	char *keyword_fields[]={
				324	"arg",
				325	"value",
				326	};
				327	PyTypeObject *alias_type;
				328	static PyObject* ast2obj_alias(void*);
				329	char *alias_fields[]={
				330	"name",
				331	"asname",
				332	};
				333
				334
				335	static PyTypeObject* make_type(char type, PyTypeObject base, char**fields, int num_fields)
				336	{
				337	PyObject fnames, result;
				338	int i;
				339	if (num_fields) {
				340	fnames = PyTuple_New(num_fields);
				341	if (!fnames) return NULL;
				342	} else {
				343	fnames = Py_None;
				344	Py_INCREF(Py_None);
				345	}
				346	for(i=0; i < num_fields; i++) {
				347	PyObject *field = PyString_FromString(fields[i]);
				348	if (!field) {
				349	Py_DECREF(fnames);
				350	return NULL;
				351	}
				352	PyTuple_SET_ITEM(fnames, i, field);
				353	}
				354	result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sO}", type, base, "_fields", fnames);
				355	Py_DECREF(fnames);
				356	return (PyTypeObject*)result;
				357	}
				358
				359	static PyObject* ast2obj_list(asdl_seq seq, PyObject (func)(void))
				360	{
				361	int i, n = asdl_seq_LEN(seq);
				362	PyObject *result = PyList_New(n);
				363	PyObject *value;
				364	if (!result)
				365	return NULL;
				366	for (i = 0; i < n; i++) {
				367	value = func(asdl_seq_GET(seq, i));
				368	if (!value) {
				369	Py_DECREF(result);
				370	return NULL;
				371	}
				372	PyList_SET_ITEM(result, i, value);
				373	}
				374	return result;
				375	}
				376
				377	static PyObject* ast2obj_object(void *o)
				378	{
				379	if (!o)
				380	o = Py_None;
				381	Py_INCREF((PyObject*)o);
				382	return (PyObject*)o;
				383	}
				384	#define ast2obj_identifier ast2obj_object
				385	#define ast2obj_string ast2obj_object
				386	static PyObject* ast2obj_bool(bool b)
				387	{
				388	return PyBool_FromLong(b);
				389	}
				390
				391	static int initialized;
				392	static int init_types(void)
				393	{
				394	if (initialized) return 1;
				395	mod_type = make_type("mod", &PyBaseObject_Type, NULL, 0);
				396	Module_type = make_type("Module", mod_type, Module_fields, 1);
				397	Interactive_type = make_type("Interactive", mod_type,
				398	Interactive_fields, 1);
				399	Expression_type = make_type("Expression", mod_type, Expression_fields,
				400	1);
				401	Suite_type = make_type("Suite", mod_type, Suite_fields, 1);
				402	stmt_type = make_type("stmt", &PyBaseObject_Type, NULL, 0);
				403	FunctionDef_type = make_type("FunctionDef", stmt_type,
				404	FunctionDef_fields, 4);
				405	ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 3);
				406	Return_type = make_type("Return", stmt_type, Return_fields, 1);
				407	Delete_type = make_type("Delete", stmt_type, Delete_fields, 1);
				408	Assign_type = make_type("Assign", stmt_type, Assign_fields, 2);
				409	AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);
				410	Print_type = make_type("Print", stmt_type, Print_fields, 3);
				411	For_type = make_type("For", stmt_type, For_fields, 4);
				412	While_type = make_type("While", stmt_type, While_fields, 3);
				413	If_type = make_type("If", stmt_type, If_fields, 3);
				414	Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);
				415	TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);
				416	TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields,
				417	2);
				418	Assert_type = make_type("Assert", stmt_type, Assert_fields, 2);
				419	Import_type = make_type("Import", stmt_type, Import_fields, 1);
				420	ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields,
				421	2);
				422	Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);
				423	Global_type = make_type("Global", stmt_type, Global_fields, 1);
				424	Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	425	Pass_type = make_type("Pass", stmt_type, NULL, 0);
				426	Break_type = make_type("Break", stmt_type, NULL, 0);
				427	Continue_type = make_type("Continue", stmt_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	428	expr_type = make_type("expr", &PyBaseObject_Type, NULL, 0);
				429	BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);
				430	BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);
				431	UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2);
				432	Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2);
				433	Dict_type = make_type("Dict", expr_type, Dict_fields, 2);
				434	ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2);
				435	GeneratorExp_type = make_type("GeneratorExp", expr_type,
				436	GeneratorExp_fields, 2);
				437	Yield_type = make_type("Yield", expr_type, Yield_fields, 1);
				438	Compare_type = make_type("Compare", expr_type, Compare_fields, 3);
				439	Call_type = make_type("Call", expr_type, Call_fields, 5);
				440	Repr_type = make_type("Repr", expr_type, Repr_fields, 1);
				441	Num_type = make_type("Num", expr_type, Num_fields, 1);
				442	Str_type = make_type("Str", expr_type, Str_fields, 1);
				443	Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3);
				444	Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3);
				445	Name_type = make_type("Name", expr_type, Name_fields, 2);
				446	List_type = make_type("List", expr_type, List_fields, 2);
				447	Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);
				448	expr_context_type = make_type("expr_context", &PyBaseObject_Type, NULL,
				449	0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	450	Load_type = make_type("Load", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	451	Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	452	Store_type = make_type("Store", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	453	Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	454	Del_type = make_type("Del", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	455	Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	456	AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	457	AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	458	AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	459	AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	460	Param_type = make_type("Param", expr_context_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	461	Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);
				462	slice_type = make_type("slice", &PyBaseObject_Type, NULL, 0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	463	Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	464	Slice_type = make_type("Slice", slice_type, Slice_fields, 3);
				465	ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);
				466	Index_type = make_type("Index", slice_type, Index_fields, 1);
				467	boolop_type = make_type("boolop", &PyBaseObject_Type, NULL, 0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	468	And_type = make_type("And", boolop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	469	And_singleton = PyType_GenericNew(And_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	470	Or_type = make_type("Or", boolop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	471	Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);
				472	operator_type = make_type("operator", &PyBaseObject_Type, NULL, 0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	473	Add_type = make_type("Add", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	474	Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	475	Sub_type = make_type("Sub", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	476	Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	477	Mult_type = make_type("Mult", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	478	Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	479	Div_type = make_type("Div", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	480	Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	481	Mod_type = make_type("Mod", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	482	Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	483	Pow_type = make_type("Pow", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	484	Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	485	LShift_type = make_type("LShift", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	486	LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	487	RShift_type = make_type("RShift", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	488	RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	489	BitOr_type = make_type("BitOr", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	490	BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	491	BitXor_type = make_type("BitXor", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	492	BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	493	BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	494	BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	495	FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	496	FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);
				497	unaryop_type = make_type("unaryop", &PyBaseObject_Type, NULL, 0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	498	Invert_type = make_type("Invert", unaryop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	499	Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	500	Not_type = make_type("Not", unaryop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	501	Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	502	UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	503	UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	504	USub_type = make_type("USub", unaryop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	505	USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);
				506	cmpop_type = make_type("cmpop", &PyBaseObject_Type, NULL, 0);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	507	Eq_type = make_type("Eq", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	508	Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	509	NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	510	NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	511	Lt_type = make_type("Lt", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	512	Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	513	LtE_type = make_type("LtE", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	514	LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	515	Gt_type = make_type("Gt", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	516	Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	517	GtE_type = make_type("GtE", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	518	GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	519	Is_type = make_type("Is", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	520	Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	521	IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	522	IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	523	In_type = make_type("In", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	524	In_singleton = PyType_GenericNew(In_type, NULL, NULL);
Martin v. Löwis	8d0701d	2006-02-26 23:40:20 +0000	[diff] [blame^]	525	NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	526	NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);
				527	comprehension_type = make_type("comprehension", &PyBaseObject_Type,
				528	comprehension_fields, 3);
				529	excepthandler_type = make_type("excepthandler", &PyBaseObject_Type,
				530	excepthandler_fields, 3);
				531	arguments_type = make_type("arguments", &PyBaseObject_Type,
				532	arguments_fields, 4);
				533	keyword_type = make_type("keyword", &PyBaseObject_Type, keyword_fields,
				534	2);
				535	alias_type = make_type("alias", &PyBaseObject_Type, alias_fields, 2);
				536	return 1;
				537	}
Neal Norwitz	7b5a604	2005-11-13 19:14:20 +0000	[diff] [blame]	538
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	539	mod_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	540	Module(asdl_seq * body, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	541	{
				542	mod_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	543	p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	544	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	545	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	546	return NULL;
				547	}
				548	p->kind = Module_kind;
				549	p->v.Module.body = body;
				550	return p;
				551	}
				552
				553	mod_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	554	Interactive(asdl_seq * body, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	555	{
				556	mod_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	557	p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	558	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	559	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	560	return NULL;
				561	}
				562	p->kind = Interactive_kind;
				563	p->v.Interactive.body = body;
				564	return p;
				565	}
				566
				567	mod_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	568	Expression(expr_ty body, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	569	{
				570	mod_ty p;
				571	if (!body) {
				572	PyErr_SetString(PyExc_ValueError,
				573	"field body is required for Expression");
				574	return NULL;
				575	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	576	p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	577	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	578	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	579	return NULL;
				580	}
				581	p->kind = Expression_kind;
				582	p->v.Expression.body = body;
				583	return p;
				584	}
				585
				586	mod_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	587	Suite(asdl_seq * body, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	588	{
				589	mod_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	590	p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	591	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	592	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	593	return NULL;
				594	}
				595	p->kind = Suite_kind;
				596	p->v.Suite.body = body;
				597	return p;
				598	}
				599
				600	stmt_ty
				601	FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	602	decorators, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	603	{
				604	stmt_ty p;
				605	if (!name) {
				606	PyErr_SetString(PyExc_ValueError,
				607	"field name is required for FunctionDef");
				608	return NULL;
				609	}
				610	if (!args) {
				611	PyErr_SetString(PyExc_ValueError,
				612	"field args is required for FunctionDef");
				613	return NULL;
				614	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	615	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	616	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	617	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	618	return NULL;
				619	}
				620	p->kind = FunctionDef_kind;
				621	p->v.FunctionDef.name = name;
				622	p->v.FunctionDef.args = args;
				623	p->v.FunctionDef.body = body;
				624	p->v.FunctionDef.decorators = decorators;
				625	p->lineno = lineno;
				626	return p;
				627	}
				628
				629	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	630	ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno,
				631	PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	632	{
				633	stmt_ty p;
				634	if (!name) {
				635	PyErr_SetString(PyExc_ValueError,
				636	"field name is required for ClassDef");
				637	return NULL;
				638	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	639	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	640	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	641	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	642	return NULL;
				643	}
				644	p->kind = ClassDef_kind;
				645	p->v.ClassDef.name = name;
				646	p->v.ClassDef.bases = bases;
				647	p->v.ClassDef.body = body;
				648	p->lineno = lineno;
				649	return p;
				650	}
				651
				652	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	653	Return(expr_ty value, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	654	{
				655	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	656	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	657	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	658	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	659	return NULL;
				660	}
				661	p->kind = Return_kind;
				662	p->v.Return.value = value;
				663	p->lineno = lineno;
				664	return p;
				665	}
				666
				667	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	668	Delete(asdl_seq * targets, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	669	{
				670	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	671	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	672	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	673	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	674	return NULL;
				675	}
				676	p->kind = Delete_kind;
				677	p->v.Delete.targets = targets;
				678	p->lineno = lineno;
				679	return p;
				680	}
				681
				682	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	683	Assign(asdl_seq * targets, expr_ty value, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	684	{
				685	stmt_ty p;
				686	if (!value) {
				687	PyErr_SetString(PyExc_ValueError,
				688	"field value is required for Assign");
				689	return NULL;
				690	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	691	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	692	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	693	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	694	return NULL;
				695	}
				696	p->kind = Assign_kind;
				697	p->v.Assign.targets = targets;
				698	p->v.Assign.value = value;
				699	p->lineno = lineno;
				700	return p;
				701	}
				702
				703	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	704	AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, PyArena
				705	*arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	706	{
				707	stmt_ty p;
				708	if (!target) {
				709	PyErr_SetString(PyExc_ValueError,
				710	"field target is required for AugAssign");
				711	return NULL;
				712	}
				713	if (!op) {
				714	PyErr_SetString(PyExc_ValueError,
				715	"field op is required for AugAssign");
				716	return NULL;
				717	}
				718	if (!value) {
				719	PyErr_SetString(PyExc_ValueError,
				720	"field value is required for AugAssign");
				721	return NULL;
				722	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	723	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	724	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	725	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	726	return NULL;
				727	}
				728	p->kind = AugAssign_kind;
				729	p->v.AugAssign.target = target;
				730	p->v.AugAssign.op = op;
				731	p->v.AugAssign.value = value;
				732	p->lineno = lineno;
				733	return p;
				734	}
				735
				736	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	737	Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	738	{
				739	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	740	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	741	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	742	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	743	return NULL;
				744	}
				745	p->kind = Print_kind;
				746	p->v.Print.dest = dest;
				747	p->v.Print.values = values;
				748	p->v.Print.nl = nl;
				749	p->lineno = lineno;
				750	return p;
				751	}
				752
				753	stmt_ty
				754	For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	755	lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	756	{
				757	stmt_ty p;
				758	if (!target) {
				759	PyErr_SetString(PyExc_ValueError,
				760	"field target is required for For");
				761	return NULL;
				762	}
				763	if (!iter) {
				764	PyErr_SetString(PyExc_ValueError,
				765	"field iter is required for For");
				766	return NULL;
				767	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	768	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	769	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	770	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	771	return NULL;
				772	}
				773	p->kind = For_kind;
				774	p->v.For.target = target;
				775	p->v.For.iter = iter;
				776	p->v.For.body = body;
				777	p->v.For.orelse = orelse;
				778	p->lineno = lineno;
				779	return p;
				780	}
				781
				782	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	783	While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, PyArena
				784	*arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	785	{
				786	stmt_ty p;
				787	if (!test) {
				788	PyErr_SetString(PyExc_ValueError,
				789	"field test is required for While");
				790	return NULL;
				791	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	792	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	793	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	794	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	795	return NULL;
				796	}
				797	p->kind = While_kind;
				798	p->v.While.test = test;
				799	p->v.While.body = body;
				800	p->v.While.orelse = orelse;
				801	p->lineno = lineno;
				802	return p;
				803	}
				804
				805	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	806	If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	807	{
				808	stmt_ty p;
				809	if (!test) {
				810	PyErr_SetString(PyExc_ValueError,
				811	"field test is required for If");
				812	return NULL;
				813	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	814	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	815	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	816	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	817	return NULL;
				818	}
				819	p->kind = If_kind;
				820	p->v.If.test = test;
				821	p->v.If.body = body;
				822	p->v.If.orelse = orelse;
				823	p->lineno = lineno;
				824	return p;
				825	}
				826
				827	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	828	Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	829	{
				830	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	831	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	832	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	833	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	834	return NULL;
				835	}
				836	p->kind = Raise_kind;
				837	p->v.Raise.type = type;
				838	p->v.Raise.inst = inst;
				839	p->v.Raise.tback = tback;
				840	p->lineno = lineno;
				841	return p;
				842	}
				843
				844	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	845	TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno,
				846	PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	847	{
				848	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	849	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	850	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	851	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	852	return NULL;
				853	}
				854	p->kind = TryExcept_kind;
				855	p->v.TryExcept.body = body;
				856	p->v.TryExcept.handlers = handlers;
				857	p->v.TryExcept.orelse = orelse;
				858	p->lineno = lineno;
				859	return p;
				860	}
				861
				862	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	863	TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	864	{
				865	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	866	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	867	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	868	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	869	return NULL;
				870	}
				871	p->kind = TryFinally_kind;
				872	p->v.TryFinally.body = body;
				873	p->v.TryFinally.finalbody = finalbody;
				874	p->lineno = lineno;
				875	return p;
				876	}
				877
				878	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	879	Assert(expr_ty test, expr_ty msg, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	880	{
				881	stmt_ty p;
				882	if (!test) {
				883	PyErr_SetString(PyExc_ValueError,
				884	"field test is required for Assert");
				885	return NULL;
				886	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	887	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	888	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	889	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	890	return NULL;
				891	}
				892	p->kind = Assert_kind;
				893	p->v.Assert.test = test;
				894	p->v.Assert.msg = msg;
				895	p->lineno = lineno;
				896	return p;
				897	}
				898
				899	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	900	Import(asdl_seq * names, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	901	{
				902	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	903	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	904	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	905	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	906	return NULL;
				907	}
				908	p->kind = Import_kind;
				909	p->v.Import.names = names;
				910	p->lineno = lineno;
				911	return p;
				912	}
				913
				914	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	915	ImportFrom(identifier module, asdl_seq * names, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	916	{
				917	stmt_ty p;
				918	if (!module) {
				919	PyErr_SetString(PyExc_ValueError,
				920	"field module is required for ImportFrom");
				921	return NULL;
				922	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	923	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	924	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	925	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	926	return NULL;
				927	}
				928	p->kind = ImportFrom_kind;
				929	p->v.ImportFrom.module = module;
				930	p->v.ImportFrom.names = names;
				931	p->lineno = lineno;
				932	return p;
				933	}
				934
				935	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	936	Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	937	{
				938	stmt_ty p;
				939	if (!body) {
				940	PyErr_SetString(PyExc_ValueError,
				941	"field body is required for Exec");
				942	return NULL;
				943	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	944	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	945	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	946	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	947	return NULL;
				948	}
				949	p->kind = Exec_kind;
				950	p->v.Exec.body = body;
				951	p->v.Exec.globals = globals;
				952	p->v.Exec.locals = locals;
				953	p->lineno = lineno;
				954	return p;
				955	}
				956
				957	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	958	Global(asdl_seq * names, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	959	{
				960	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	961	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	962	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	963	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	964	return NULL;
				965	}
				966	p->kind = Global_kind;
				967	p->v.Global.names = names;
				968	p->lineno = lineno;
				969	return p;
				970	}
				971
				972	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	973	Expr(expr_ty value, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	974	{
				975	stmt_ty p;
				976	if (!value) {
				977	PyErr_SetString(PyExc_ValueError,
				978	"field value is required for Expr");
				979	return NULL;
				980	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	981	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	982	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	983	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	984	return NULL;
				985	}
				986	p->kind = Expr_kind;
				987	p->v.Expr.value = value;
				988	p->lineno = lineno;
				989	return p;
				990	}
				991
				992	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	993	Pass(int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	994	{
				995	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	996	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	997	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	998	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	999	return NULL;
				1000	}
				1001	p->kind = Pass_kind;
				1002	p->lineno = lineno;
				1003	return p;
				1004	}
				1005
				1006	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1007	Break(int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1008	{
				1009	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1010	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1011	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1012	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1013	return NULL;
				1014	}
				1015	p->kind = Break_kind;
				1016	p->lineno = lineno;
				1017	return p;
				1018	}
				1019
				1020	stmt_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1021	Continue(int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1022	{
				1023	stmt_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1024	p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1025	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1026	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1027	return NULL;
				1028	}
				1029	p->kind = Continue_kind;
				1030	p->lineno = lineno;
				1031	return p;
				1032	}
				1033
				1034	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1035	BoolOp(boolop_ty op, asdl_seq * values, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1036	{
				1037	expr_ty p;
				1038	if (!op) {
				1039	PyErr_SetString(PyExc_ValueError,
				1040	"field op is required for BoolOp");
				1041	return NULL;
				1042	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1043	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1044	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1045	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1046	return NULL;
				1047	}
				1048	p->kind = BoolOp_kind;
				1049	p->v.BoolOp.op = op;
				1050	p->v.BoolOp.values = values;
				1051	p->lineno = lineno;
				1052	return p;
				1053	}
				1054
				1055	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1056	BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1057	{
				1058	expr_ty p;
				1059	if (!left) {
				1060	PyErr_SetString(PyExc_ValueError,
				1061	"field left is required for BinOp");
				1062	return NULL;
				1063	}
				1064	if (!op) {
				1065	PyErr_SetString(PyExc_ValueError,
				1066	"field op is required for BinOp");
				1067	return NULL;
				1068	}
				1069	if (!right) {
				1070	PyErr_SetString(PyExc_ValueError,
				1071	"field right is required for BinOp");
				1072	return NULL;
				1073	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1074	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1075	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1076	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1077	return NULL;
				1078	}
				1079	p->kind = BinOp_kind;
				1080	p->v.BinOp.left = left;
				1081	p->v.BinOp.op = op;
				1082	p->v.BinOp.right = right;
				1083	p->lineno = lineno;
				1084	return p;
				1085	}
				1086
				1087	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1088	UnaryOp(unaryop_ty op, expr_ty operand, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1089	{
				1090	expr_ty p;
				1091	if (!op) {
				1092	PyErr_SetString(PyExc_ValueError,
				1093	"field op is required for UnaryOp");
				1094	return NULL;
				1095	}
				1096	if (!operand) {
				1097	PyErr_SetString(PyExc_ValueError,
				1098	"field operand is required for UnaryOp");
				1099	return NULL;
				1100	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1101	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1102	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1103	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1104	return NULL;
				1105	}
				1106	p->kind = UnaryOp_kind;
				1107	p->v.UnaryOp.op = op;
				1108	p->v.UnaryOp.operand = operand;
				1109	p->lineno = lineno;
				1110	return p;
				1111	}
				1112
				1113	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1114	Lambda(arguments_ty args, expr_ty body, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1115	{
				1116	expr_ty p;
				1117	if (!args) {
				1118	PyErr_SetString(PyExc_ValueError,
				1119	"field args is required for Lambda");
				1120	return NULL;
				1121	}
				1122	if (!body) {
				1123	PyErr_SetString(PyExc_ValueError,
				1124	"field body is required for Lambda");
				1125	return NULL;
				1126	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1127	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1128	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1129	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1130	return NULL;
				1131	}
				1132	p->kind = Lambda_kind;
				1133	p->v.Lambda.args = args;
				1134	p->v.Lambda.body = body;
				1135	p->lineno = lineno;
				1136	return p;
				1137	}
				1138
				1139	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1140	Dict(asdl_seq * keys, asdl_seq * values, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1141	{
				1142	expr_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1143	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1144	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1145	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1146	return NULL;
				1147	}
				1148	p->kind = Dict_kind;
				1149	p->v.Dict.keys = keys;
				1150	p->v.Dict.values = values;
				1151	p->lineno = lineno;
				1152	return p;
				1153	}
				1154
				1155	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1156	ListComp(expr_ty elt, asdl_seq * generators, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1157	{
				1158	expr_ty p;
				1159	if (!elt) {
				1160	PyErr_SetString(PyExc_ValueError,
				1161	"field elt is required for ListComp");
				1162	return NULL;
				1163	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1164	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1165	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1166	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1167	return NULL;
				1168	}
				1169	p->kind = ListComp_kind;
				1170	p->v.ListComp.elt = elt;
				1171	p->v.ListComp.generators = generators;
				1172	p->lineno = lineno;
				1173	return p;
				1174	}
				1175
				1176	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1177	GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1178	{
				1179	expr_ty p;
				1180	if (!elt) {
				1181	PyErr_SetString(PyExc_ValueError,
				1182	"field elt is required for GeneratorExp");
				1183	return NULL;
				1184	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1185	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1186	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1187	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1188	return NULL;
				1189	}
				1190	p->kind = GeneratorExp_kind;
				1191	p->v.GeneratorExp.elt = elt;
				1192	p->v.GeneratorExp.generators = generators;
				1193	p->lineno = lineno;
				1194	return p;
				1195	}
				1196
				1197	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1198	Yield(expr_ty value, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1199	{
				1200	expr_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1201	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1202	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1203	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1204	return NULL;
				1205	}
				1206	p->kind = Yield_kind;
				1207	p->v.Yield.value = value;
				1208	p->lineno = lineno;
				1209	return p;
				1210	}
				1211
				1212	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1213	Compare(expr_ty left, asdl_seq * ops, asdl_seq * comparators, int lineno,
				1214	PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1215	{
				1216	expr_ty p;
				1217	if (!left) {
				1218	PyErr_SetString(PyExc_ValueError,
				1219	"field left is required for Compare");
				1220	return NULL;
				1221	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1222	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1223	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1224	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1225	return NULL;
				1226	}
				1227	p->kind = Compare_kind;
				1228	p->v.Compare.left = left;
				1229	p->v.Compare.ops = ops;
				1230	p->v.Compare.comparators = comparators;
				1231	p->lineno = lineno;
				1232	return p;
				1233	}
				1234
				1235	expr_ty
				1236	Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1237	expr_ty kwargs, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1238	{
				1239	expr_ty p;
				1240	if (!func) {
				1241	PyErr_SetString(PyExc_ValueError,
				1242	"field func is required for Call");
				1243	return NULL;
				1244	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1245	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1246	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1247	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1248	return NULL;
				1249	}
				1250	p->kind = Call_kind;
				1251	p->v.Call.func = func;
				1252	p->v.Call.args = args;
				1253	p->v.Call.keywords = keywords;
				1254	p->v.Call.starargs = starargs;
				1255	p->v.Call.kwargs = kwargs;
				1256	p->lineno = lineno;
				1257	return p;
				1258	}
				1259
				1260	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1261	Repr(expr_ty value, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1262	{
				1263	expr_ty p;
				1264	if (!value) {
				1265	PyErr_SetString(PyExc_ValueError,
				1266	"field value is required for Repr");
				1267	return NULL;
				1268	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1269	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1270	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1271	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1272	return NULL;
				1273	}
				1274	p->kind = Repr_kind;
				1275	p->v.Repr.value = value;
				1276	p->lineno = lineno;
				1277	return p;
				1278	}
				1279
				1280	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1281	Num(object n, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1282	{
				1283	expr_ty p;
				1284	if (!n) {
				1285	PyErr_SetString(PyExc_ValueError,
				1286	"field n is required for Num");
				1287	return NULL;
				1288	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1289	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1290	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1291	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1292	return NULL;
				1293	}
				1294	p->kind = Num_kind;
				1295	p->v.Num.n = n;
				1296	p->lineno = lineno;
				1297	return p;
				1298	}
				1299
				1300	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1301	Str(string s, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1302	{
				1303	expr_ty p;
				1304	if (!s) {
				1305	PyErr_SetString(PyExc_ValueError,
				1306	"field s is required for Str");
				1307	return NULL;
				1308	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1309	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1310	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1311	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1312	return NULL;
				1313	}
				1314	p->kind = Str_kind;
				1315	p->v.Str.s = s;
				1316	p->lineno = lineno;
				1317	return p;
				1318	}
				1319
				1320	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1321	Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno,
				1322	PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1323	{
				1324	expr_ty p;
				1325	if (!value) {
				1326	PyErr_SetString(PyExc_ValueError,
				1327	"field value is required for Attribute");
				1328	return NULL;
				1329	}
				1330	if (!attr) {
				1331	PyErr_SetString(PyExc_ValueError,
				1332	"field attr is required for Attribute");
				1333	return NULL;
				1334	}
				1335	if (!ctx) {
				1336	PyErr_SetString(PyExc_ValueError,
				1337	"field ctx is required for Attribute");
				1338	return NULL;
				1339	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1340	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1341	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1342	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1343	return NULL;
				1344	}
				1345	p->kind = Attribute_kind;
				1346	p->v.Attribute.value = value;
				1347	p->v.Attribute.attr = attr;
				1348	p->v.Attribute.ctx = ctx;
				1349	p->lineno = lineno;
				1350	return p;
				1351	}
				1352
				1353	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1354	Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno,
				1355	PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1356	{
				1357	expr_ty p;
				1358	if (!value) {
				1359	PyErr_SetString(PyExc_ValueError,
				1360	"field value is required for Subscript");
				1361	return NULL;
				1362	}
				1363	if (!slice) {
				1364	PyErr_SetString(PyExc_ValueError,
				1365	"field slice is required for Subscript");
				1366	return NULL;
				1367	}
				1368	if (!ctx) {
				1369	PyErr_SetString(PyExc_ValueError,
				1370	"field ctx is required for Subscript");
				1371	return NULL;
				1372	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1373	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1374	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1375	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1376	return NULL;
				1377	}
				1378	p->kind = Subscript_kind;
				1379	p->v.Subscript.value = value;
				1380	p->v.Subscript.slice = slice;
				1381	p->v.Subscript.ctx = ctx;
				1382	p->lineno = lineno;
				1383	return p;
				1384	}
				1385
				1386	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1387	Name(identifier id, expr_context_ty ctx, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1388	{
				1389	expr_ty p;
				1390	if (!id) {
				1391	PyErr_SetString(PyExc_ValueError,
				1392	"field id is required for Name");
				1393	return NULL;
				1394	}
				1395	if (!ctx) {
				1396	PyErr_SetString(PyExc_ValueError,
				1397	"field ctx is required for Name");
				1398	return NULL;
				1399	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1400	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1401	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1402	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1403	return NULL;
				1404	}
				1405	p->kind = Name_kind;
				1406	p->v.Name.id = id;
				1407	p->v.Name.ctx = ctx;
				1408	p->lineno = lineno;
				1409	return p;
				1410	}
				1411
				1412	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1413	List(asdl_seq * elts, expr_context_ty ctx, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1414	{
				1415	expr_ty p;
				1416	if (!ctx) {
				1417	PyErr_SetString(PyExc_ValueError,
				1418	"field ctx is required for List");
				1419	return NULL;
				1420	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1421	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1422	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1423	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1424	return NULL;
				1425	}
				1426	p->kind = List_kind;
				1427	p->v.List.elts = elts;
				1428	p->v.List.ctx = ctx;
				1429	p->lineno = lineno;
				1430	return p;
				1431	}
				1432
				1433	expr_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1434	Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1435	{
				1436	expr_ty p;
				1437	if (!ctx) {
				1438	PyErr_SetString(PyExc_ValueError,
				1439	"field ctx is required for Tuple");
				1440	return NULL;
				1441	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1442	p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1443	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1444	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1445	return NULL;
				1446	}
				1447	p->kind = Tuple_kind;
				1448	p->v.Tuple.elts = elts;
				1449	p->v.Tuple.ctx = ctx;
				1450	p->lineno = lineno;
				1451	return p;
				1452	}
				1453
				1454	slice_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1455	Ellipsis(PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1456	{
				1457	slice_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1458	p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1459	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1460	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1461	return NULL;
				1462	}
				1463	p->kind = Ellipsis_kind;
				1464	return p;
				1465	}
				1466
				1467	slice_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1468	Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1469	{
				1470	slice_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1471	p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1472	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1473	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1474	return NULL;
				1475	}
				1476	p->kind = Slice_kind;
				1477	p->v.Slice.lower = lower;
				1478	p->v.Slice.upper = upper;
				1479	p->v.Slice.step = step;
				1480	return p;
				1481	}
				1482
				1483	slice_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1484	ExtSlice(asdl_seq * dims, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1485	{
				1486	slice_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1487	p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1488	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1489	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1490	return NULL;
				1491	}
				1492	p->kind = ExtSlice_kind;
				1493	p->v.ExtSlice.dims = dims;
				1494	return p;
				1495	}
				1496
				1497	slice_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1498	Index(expr_ty value, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1499	{
				1500	slice_ty p;
				1501	if (!value) {
				1502	PyErr_SetString(PyExc_ValueError,
				1503	"field value is required for Index");
				1504	return NULL;
				1505	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1506	p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1507	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1508	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1509	return NULL;
				1510	}
				1511	p->kind = Index_kind;
				1512	p->v.Index.value = value;
				1513	return p;
				1514	}
				1515
				1516	comprehension_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1517	comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1518	{
				1519	comprehension_ty p;
				1520	if (!target) {
				1521	PyErr_SetString(PyExc_ValueError,
				1522	"field target is required for comprehension");
				1523	return NULL;
				1524	}
				1525	if (!iter) {
				1526	PyErr_SetString(PyExc_ValueError,
				1527	"field iter is required for comprehension");
				1528	return NULL;
				1529	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1530	p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1531	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1532	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1533	return NULL;
				1534	}
				1535	p->target = target;
				1536	p->iter = iter;
				1537	p->ifs = ifs;
				1538	return p;
				1539	}
				1540
				1541	excepthandler_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1542	excepthandler(expr_ty type, expr_ty name, asdl_seq * body, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1543	{
				1544	excepthandler_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1545	p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1546	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1547	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1548	return NULL;
				1549	}
				1550	p->type = type;
				1551	p->name = name;
				1552	p->body = body;
				1553	return p;
				1554	}
				1555
				1556	arguments_ty
				1557	arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1558	defaults, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1559	{
				1560	arguments_ty p;
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1561	p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1562	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1563	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1564	return NULL;
				1565	}
				1566	p->args = args;
				1567	p->vararg = vararg;
				1568	p->kwarg = kwarg;
				1569	p->defaults = defaults;
				1570	return p;
				1571	}
				1572
				1573	keyword_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1574	keyword(identifier arg, expr_ty value, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1575	{
				1576	keyword_ty p;
				1577	if (!arg) {
				1578	PyErr_SetString(PyExc_ValueError,
				1579	"field arg is required for keyword");
				1580	return NULL;
				1581	}
				1582	if (!value) {
				1583	PyErr_SetString(PyExc_ValueError,
				1584	"field value is required for keyword");
				1585	return NULL;
				1586	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1587	p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1588	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1589	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1590	return NULL;
				1591	}
				1592	p->arg = arg;
				1593	p->value = value;
				1594	return p;
				1595	}
				1596
				1597	alias_ty
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1598	alias(identifier name, identifier asname, PyArena *arena)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1599	{
				1600	alias_ty p;
				1601	if (!name) {
				1602	PyErr_SetString(PyExc_ValueError,
				1603	"field name is required for alias");
				1604	return NULL;
				1605	}
Neal Norwitz	adb69fc	2005-12-17 20:54:49 +0000	[diff] [blame]	1606	p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1607	if (!p) {
Neal Norwitz	12ebfd7	2005-10-23 19:22:48 +0000	[diff] [blame]	1608	PyErr_NoMemory();
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1609	return NULL;
				1610	}
				1611	p->name = name;
				1612	p->asname = asname;
				1613	return p;
				1614	}
				1615
Neal Norwitz	7b5a604	2005-11-13 19:14:20 +0000	[diff] [blame]	1616
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1617	PyObject*
				1618	ast2obj_mod(void* _o)
Neal Norwitz	7b5a604	2005-11-13 19:14:20 +0000	[diff] [blame]	1619	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1620	mod_ty o = (mod_ty)_o;
				1621	PyObject result = NULL, value = NULL;
				1622	if (!o) {
				1623	Py_INCREF(Py_None);
				1624	return Py_None;
				1625	}
Neal Norwitz	7b5a604	2005-11-13 19:14:20 +0000	[diff] [blame]	1626
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1627	switch (o->kind) {
				1628	case Module_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1629	result = PyType_GenericNew(Module_type, NULL, NULL);
				1630	if (!result) goto failed;
				1631	value = ast2obj_list(o->v.Module.body, ast2obj_stmt);
				1632	if (!value) goto failed;
				1633	if (PyObject_SetAttrString(result, "body", value) == -1)
				1634	goto failed;
				1635	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1636	break;
				1637	case Interactive_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1638	result = PyType_GenericNew(Interactive_type, NULL, NULL);
				1639	if (!result) goto failed;
				1640	value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt);
				1641	if (!value) goto failed;
				1642	if (PyObject_SetAttrString(result, "body", value) == -1)
				1643	goto failed;
				1644	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1645	break;
				1646	case Expression_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1647	result = PyType_GenericNew(Expression_type, NULL, NULL);
				1648	if (!result) goto failed;
				1649	value = ast2obj_expr(o->v.Expression.body);
				1650	if (!value) goto failed;
				1651	if (PyObject_SetAttrString(result, "body", value) == -1)
				1652	goto failed;
				1653	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1654	break;
				1655	case Suite_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1656	result = PyType_GenericNew(Suite_type, NULL, NULL);
				1657	if (!result) goto failed;
				1658	value = ast2obj_list(o->v.Suite.body, ast2obj_stmt);
				1659	if (!value) goto failed;
				1660	if (PyObject_SetAttrString(result, "body", value) == -1)
				1661	goto failed;
				1662	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1663	break;
				1664	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1665
				1666	return result;
				1667	failed:
				1668	Py_XDECREF(value);
				1669	Py_XDECREF(result);
				1670	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1671	}
				1672
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1673	PyObject*
				1674	ast2obj_stmt(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1675	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1676	stmt_ty o = (stmt_ty)_o;
				1677	PyObject result = NULL, value = NULL;
				1678	if (!o) {
				1679	Py_INCREF(Py_None);
				1680	return Py_None;
				1681	}
				1682
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1683	switch (o->kind) {
				1684	case FunctionDef_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1685	result = PyType_GenericNew(FunctionDef_type, NULL, NULL);
				1686	if (!result) goto failed;
				1687	value = ast2obj_identifier(o->v.FunctionDef.name);
				1688	if (!value) goto failed;
				1689	if (PyObject_SetAttrString(result, "name", value) == -1)
				1690	goto failed;
				1691	Py_DECREF(value);
				1692	value = ast2obj_arguments(o->v.FunctionDef.args);
				1693	if (!value) goto failed;
				1694	if (PyObject_SetAttrString(result, "args", value) == -1)
				1695	goto failed;
				1696	Py_DECREF(value);
				1697	value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt);
				1698	if (!value) goto failed;
				1699	if (PyObject_SetAttrString(result, "body", value) == -1)
				1700	goto failed;
				1701	Py_DECREF(value);
				1702	value = ast2obj_list(o->v.FunctionDef.decorators, ast2obj_expr);
				1703	if (!value) goto failed;
				1704	if (PyObject_SetAttrString(result, "decorators", value) == -1)
				1705	goto failed;
				1706	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1707	break;
				1708	case ClassDef_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1709	result = PyType_GenericNew(ClassDef_type, NULL, NULL);
				1710	if (!result) goto failed;
				1711	value = ast2obj_identifier(o->v.ClassDef.name);
				1712	if (!value) goto failed;
				1713	if (PyObject_SetAttrString(result, "name", value) == -1)
				1714	goto failed;
				1715	Py_DECREF(value);
				1716	value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr);
				1717	if (!value) goto failed;
				1718	if (PyObject_SetAttrString(result, "bases", value) == -1)
				1719	goto failed;
				1720	Py_DECREF(value);
				1721	value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt);
				1722	if (!value) goto failed;
				1723	if (PyObject_SetAttrString(result, "body", value) == -1)
				1724	goto failed;
				1725	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1726	break;
				1727	case Return_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1728	result = PyType_GenericNew(Return_type, NULL, NULL);
				1729	if (!result) goto failed;
				1730	value = ast2obj_expr(o->v.Return.value);
				1731	if (!value) goto failed;
				1732	if (PyObject_SetAttrString(result, "value", value) == -1)
				1733	goto failed;
				1734	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1735	break;
				1736	case Delete_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1737	result = PyType_GenericNew(Delete_type, NULL, NULL);
				1738	if (!result) goto failed;
				1739	value = ast2obj_list(o->v.Delete.targets, ast2obj_expr);
				1740	if (!value) goto failed;
				1741	if (PyObject_SetAttrString(result, "targets", value) == -1)
				1742	goto failed;
				1743	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1744	break;
				1745	case Assign_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1746	result = PyType_GenericNew(Assign_type, NULL, NULL);
				1747	if (!result) goto failed;
				1748	value = ast2obj_list(o->v.Assign.targets, ast2obj_expr);
				1749	if (!value) goto failed;
				1750	if (PyObject_SetAttrString(result, "targets", value) == -1)
				1751	goto failed;
				1752	Py_DECREF(value);
				1753	value = ast2obj_expr(o->v.Assign.value);
				1754	if (!value) goto failed;
				1755	if (PyObject_SetAttrString(result, "value", value) == -1)
				1756	goto failed;
				1757	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1758	break;
				1759	case AugAssign_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1760	result = PyType_GenericNew(AugAssign_type, NULL, NULL);
				1761	if (!result) goto failed;
				1762	value = ast2obj_expr(o->v.AugAssign.target);
				1763	if (!value) goto failed;
				1764	if (PyObject_SetAttrString(result, "target", value) == -1)
				1765	goto failed;
				1766	Py_DECREF(value);
				1767	value = ast2obj_operator(o->v.AugAssign.op);
				1768	if (!value) goto failed;
				1769	if (PyObject_SetAttrString(result, "op", value) == -1)
				1770	goto failed;
				1771	Py_DECREF(value);
				1772	value = ast2obj_expr(o->v.AugAssign.value);
				1773	if (!value) goto failed;
				1774	if (PyObject_SetAttrString(result, "value", value) == -1)
				1775	goto failed;
				1776	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1777	break;
				1778	case Print_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1779	result = PyType_GenericNew(Print_type, NULL, NULL);
				1780	if (!result) goto failed;
				1781	value = ast2obj_expr(o->v.Print.dest);
				1782	if (!value) goto failed;
				1783	if (PyObject_SetAttrString(result, "dest", value) == -1)
				1784	goto failed;
				1785	Py_DECREF(value);
				1786	value = ast2obj_list(o->v.Print.values, ast2obj_expr);
				1787	if (!value) goto failed;
				1788	if (PyObject_SetAttrString(result, "values", value) == -1)
				1789	goto failed;
				1790	Py_DECREF(value);
				1791	value = ast2obj_bool(o->v.Print.nl);
				1792	if (!value) goto failed;
				1793	if (PyObject_SetAttrString(result, "nl", value) == -1)
				1794	goto failed;
				1795	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1796	break;
				1797	case For_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1798	result = PyType_GenericNew(For_type, NULL, NULL);
				1799	if (!result) goto failed;
				1800	value = ast2obj_expr(o->v.For.target);
				1801	if (!value) goto failed;
				1802	if (PyObject_SetAttrString(result, "target", value) == -1)
				1803	goto failed;
				1804	Py_DECREF(value);
				1805	value = ast2obj_expr(o->v.For.iter);
				1806	if (!value) goto failed;
				1807	if (PyObject_SetAttrString(result, "iter", value) == -1)
				1808	goto failed;
				1809	Py_DECREF(value);
				1810	value = ast2obj_list(o->v.For.body, ast2obj_stmt);
				1811	if (!value) goto failed;
				1812	if (PyObject_SetAttrString(result, "body", value) == -1)
				1813	goto failed;
				1814	Py_DECREF(value);
				1815	value = ast2obj_list(o->v.For.orelse, ast2obj_stmt);
				1816	if (!value) goto failed;
				1817	if (PyObject_SetAttrString(result, "orelse", value) == -1)
				1818	goto failed;
				1819	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1820	break;
				1821	case While_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1822	result = PyType_GenericNew(While_type, NULL, NULL);
				1823	if (!result) goto failed;
				1824	value = ast2obj_expr(o->v.While.test);
				1825	if (!value) goto failed;
				1826	if (PyObject_SetAttrString(result, "test", value) == -1)
				1827	goto failed;
				1828	Py_DECREF(value);
				1829	value = ast2obj_list(o->v.While.body, ast2obj_stmt);
				1830	if (!value) goto failed;
				1831	if (PyObject_SetAttrString(result, "body", value) == -1)
				1832	goto failed;
				1833	Py_DECREF(value);
				1834	value = ast2obj_list(o->v.While.orelse, ast2obj_stmt);
				1835	if (!value) goto failed;
				1836	if (PyObject_SetAttrString(result, "orelse", value) == -1)
				1837	goto failed;
				1838	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1839	break;
				1840	case If_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1841	result = PyType_GenericNew(If_type, NULL, NULL);
				1842	if (!result) goto failed;
				1843	value = ast2obj_expr(o->v.If.test);
				1844	if (!value) goto failed;
				1845	if (PyObject_SetAttrString(result, "test", value) == -1)
				1846	goto failed;
				1847	Py_DECREF(value);
				1848	value = ast2obj_list(o->v.If.body, ast2obj_stmt);
				1849	if (!value) goto failed;
				1850	if (PyObject_SetAttrString(result, "body", value) == -1)
				1851	goto failed;
				1852	Py_DECREF(value);
				1853	value = ast2obj_list(o->v.If.orelse, ast2obj_stmt);
				1854	if (!value) goto failed;
				1855	if (PyObject_SetAttrString(result, "orelse", value) == -1)
				1856	goto failed;
				1857	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1858	break;
				1859	case Raise_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1860	result = PyType_GenericNew(Raise_type, NULL, NULL);
				1861	if (!result) goto failed;
				1862	value = ast2obj_expr(o->v.Raise.type);
				1863	if (!value) goto failed;
				1864	if (PyObject_SetAttrString(result, "type", value) == -1)
				1865	goto failed;
				1866	Py_DECREF(value);
				1867	value = ast2obj_expr(o->v.Raise.inst);
				1868	if (!value) goto failed;
				1869	if (PyObject_SetAttrString(result, "inst", value) == -1)
				1870	goto failed;
				1871	Py_DECREF(value);
				1872	value = ast2obj_expr(o->v.Raise.tback);
				1873	if (!value) goto failed;
				1874	if (PyObject_SetAttrString(result, "tback", value) == -1)
				1875	goto failed;
				1876	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1877	break;
				1878	case TryExcept_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1879	result = PyType_GenericNew(TryExcept_type, NULL, NULL);
				1880	if (!result) goto failed;
				1881	value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt);
				1882	if (!value) goto failed;
				1883	if (PyObject_SetAttrString(result, "body", value) == -1)
				1884	goto failed;
				1885	Py_DECREF(value);
				1886	value = ast2obj_list(o->v.TryExcept.handlers,
				1887	ast2obj_excepthandler);
				1888	if (!value) goto failed;
				1889	if (PyObject_SetAttrString(result, "handlers", value) == -1)
				1890	goto failed;
				1891	Py_DECREF(value);
				1892	value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt);
				1893	if (!value) goto failed;
				1894	if (PyObject_SetAttrString(result, "orelse", value) == -1)
				1895	goto failed;
				1896	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1897	break;
				1898	case TryFinally_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1899	result = PyType_GenericNew(TryFinally_type, NULL, NULL);
				1900	if (!result) goto failed;
				1901	value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt);
				1902	if (!value) goto failed;
				1903	if (PyObject_SetAttrString(result, "body", value) == -1)
				1904	goto failed;
				1905	Py_DECREF(value);
				1906	value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt);
				1907	if (!value) goto failed;
				1908	if (PyObject_SetAttrString(result, "finalbody", value) == -1)
				1909	goto failed;
				1910	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1911	break;
				1912	case Assert_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1913	result = PyType_GenericNew(Assert_type, NULL, NULL);
				1914	if (!result) goto failed;
				1915	value = ast2obj_expr(o->v.Assert.test);
				1916	if (!value) goto failed;
				1917	if (PyObject_SetAttrString(result, "test", value) == -1)
				1918	goto failed;
				1919	Py_DECREF(value);
				1920	value = ast2obj_expr(o->v.Assert.msg);
				1921	if (!value) goto failed;
				1922	if (PyObject_SetAttrString(result, "msg", value) == -1)
				1923	goto failed;
				1924	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1925	break;
				1926	case Import_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1927	result = PyType_GenericNew(Import_type, NULL, NULL);
				1928	if (!result) goto failed;
				1929	value = ast2obj_list(o->v.Import.names, ast2obj_alias);
				1930	if (!value) goto failed;
				1931	if (PyObject_SetAttrString(result, "names", value) == -1)
				1932	goto failed;
				1933	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1934	break;
				1935	case ImportFrom_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1936	result = PyType_GenericNew(ImportFrom_type, NULL, NULL);
				1937	if (!result) goto failed;
				1938	value = ast2obj_identifier(o->v.ImportFrom.module);
				1939	if (!value) goto failed;
				1940	if (PyObject_SetAttrString(result, "module", value) == -1)
				1941	goto failed;
				1942	Py_DECREF(value);
				1943	value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias);
				1944	if (!value) goto failed;
				1945	if (PyObject_SetAttrString(result, "names", value) == -1)
				1946	goto failed;
				1947	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1948	break;
				1949	case Exec_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1950	result = PyType_GenericNew(Exec_type, NULL, NULL);
				1951	if (!result) goto failed;
				1952	value = ast2obj_expr(o->v.Exec.body);
				1953	if (!value) goto failed;
				1954	if (PyObject_SetAttrString(result, "body", value) == -1)
				1955	goto failed;
				1956	Py_DECREF(value);
				1957	value = ast2obj_expr(o->v.Exec.globals);
				1958	if (!value) goto failed;
				1959	if (PyObject_SetAttrString(result, "globals", value) == -1)
				1960	goto failed;
				1961	Py_DECREF(value);
				1962	value = ast2obj_expr(o->v.Exec.locals);
				1963	if (!value) goto failed;
				1964	if (PyObject_SetAttrString(result, "locals", value) == -1)
				1965	goto failed;
				1966	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1967	break;
				1968	case Global_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1969	result = PyType_GenericNew(Global_type, NULL, NULL);
				1970	if (!result) goto failed;
				1971	value = ast2obj_list(o->v.Global.names, ast2obj_identifier);
				1972	if (!value) goto failed;
				1973	if (PyObject_SetAttrString(result, "names", value) == -1)
				1974	goto failed;
				1975	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1976	break;
				1977	case Expr_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1978	result = PyType_GenericNew(Expr_type, NULL, NULL);
				1979	if (!result) goto failed;
				1980	value = ast2obj_expr(o->v.Expr.value);
				1981	if (!value) goto failed;
				1982	if (PyObject_SetAttrString(result, "value", value) == -1)
				1983	goto failed;
				1984	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1985	break;
				1986	case Pass_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1987	result = PyType_GenericNew(Pass_type, NULL, NULL);
				1988	if (!result) goto failed;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1989	break;
				1990	case Break_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1991	result = PyType_GenericNew(Break_type, NULL, NULL);
				1992	if (!result) goto failed;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1993	break;
				1994	case Continue_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1995	result = PyType_GenericNew(Continue_type, NULL, NULL);
				1996	if (!result) goto failed;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	1997	break;
				1998	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	1999
				2000	return result;
				2001	failed:
				2002	Py_XDECREF(value);
				2003	Py_XDECREF(result);
				2004	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2005	}
				2006
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2007	PyObject*
				2008	ast2obj_expr(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2009	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2010	expr_ty o = (expr_ty)_o;
				2011	PyObject result = NULL, value = NULL;
				2012	if (!o) {
				2013	Py_INCREF(Py_None);
				2014	return Py_None;
				2015	}
				2016
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2017	switch (o->kind) {
				2018	case BoolOp_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2019	result = PyType_GenericNew(BoolOp_type, NULL, NULL);
				2020	if (!result) goto failed;
				2021	value = ast2obj_boolop(o->v.BoolOp.op);
				2022	if (!value) goto failed;
				2023	if (PyObject_SetAttrString(result, "op", value) == -1)
				2024	goto failed;
				2025	Py_DECREF(value);
				2026	value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr);
				2027	if (!value) goto failed;
				2028	if (PyObject_SetAttrString(result, "values", value) == -1)
				2029	goto failed;
				2030	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2031	break;
				2032	case BinOp_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2033	result = PyType_GenericNew(BinOp_type, NULL, NULL);
				2034	if (!result) goto failed;
				2035	value = ast2obj_expr(o->v.BinOp.left);
				2036	if (!value) goto failed;
				2037	if (PyObject_SetAttrString(result, "left", value) == -1)
				2038	goto failed;
				2039	Py_DECREF(value);
				2040	value = ast2obj_operator(o->v.BinOp.op);
				2041	if (!value) goto failed;
				2042	if (PyObject_SetAttrString(result, "op", value) == -1)
				2043	goto failed;
				2044	Py_DECREF(value);
				2045	value = ast2obj_expr(o->v.BinOp.right);
				2046	if (!value) goto failed;
				2047	if (PyObject_SetAttrString(result, "right", value) == -1)
				2048	goto failed;
				2049	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2050	break;
				2051	case UnaryOp_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2052	result = PyType_GenericNew(UnaryOp_type, NULL, NULL);
				2053	if (!result) goto failed;
				2054	value = ast2obj_unaryop(o->v.UnaryOp.op);
				2055	if (!value) goto failed;
				2056	if (PyObject_SetAttrString(result, "op", value) == -1)
				2057	goto failed;
				2058	Py_DECREF(value);
				2059	value = ast2obj_expr(o->v.UnaryOp.operand);
				2060	if (!value) goto failed;
				2061	if (PyObject_SetAttrString(result, "operand", value) == -1)
				2062	goto failed;
				2063	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2064	break;
				2065	case Lambda_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2066	result = PyType_GenericNew(Lambda_type, NULL, NULL);
				2067	if (!result) goto failed;
				2068	value = ast2obj_arguments(o->v.Lambda.args);
				2069	if (!value) goto failed;
				2070	if (PyObject_SetAttrString(result, "args", value) == -1)
				2071	goto failed;
				2072	Py_DECREF(value);
				2073	value = ast2obj_expr(o->v.Lambda.body);
				2074	if (!value) goto failed;
				2075	if (PyObject_SetAttrString(result, "body", value) == -1)
				2076	goto failed;
				2077	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2078	break;
				2079	case Dict_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2080	result = PyType_GenericNew(Dict_type, NULL, NULL);
				2081	if (!result) goto failed;
				2082	value = ast2obj_list(o->v.Dict.keys, ast2obj_expr);
				2083	if (!value) goto failed;
				2084	if (PyObject_SetAttrString(result, "keys", value) == -1)
				2085	goto failed;
				2086	Py_DECREF(value);
				2087	value = ast2obj_list(o->v.Dict.values, ast2obj_expr);
				2088	if (!value) goto failed;
				2089	if (PyObject_SetAttrString(result, "values", value) == -1)
				2090	goto failed;
				2091	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2092	break;
				2093	case ListComp_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2094	result = PyType_GenericNew(ListComp_type, NULL, NULL);
				2095	if (!result) goto failed;
				2096	value = ast2obj_expr(o->v.ListComp.elt);
				2097	if (!value) goto failed;
				2098	if (PyObject_SetAttrString(result, "elt", value) == -1)
				2099	goto failed;
				2100	Py_DECREF(value);
				2101	value = ast2obj_list(o->v.ListComp.generators,
				2102	ast2obj_comprehension);
				2103	if (!value) goto failed;
				2104	if (PyObject_SetAttrString(result, "generators", value) == -1)
				2105	goto failed;
				2106	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2107	break;
				2108	case GeneratorExp_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2109	result = PyType_GenericNew(GeneratorExp_type, NULL, NULL);
				2110	if (!result) goto failed;
				2111	value = ast2obj_expr(o->v.GeneratorExp.elt);
				2112	if (!value) goto failed;
				2113	if (PyObject_SetAttrString(result, "elt", value) == -1)
				2114	goto failed;
				2115	Py_DECREF(value);
				2116	value = ast2obj_list(o->v.GeneratorExp.generators,
				2117	ast2obj_comprehension);
				2118	if (!value) goto failed;
				2119	if (PyObject_SetAttrString(result, "generators", value) == -1)
				2120	goto failed;
				2121	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2122	break;
				2123	case Yield_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2124	result = PyType_GenericNew(Yield_type, NULL, NULL);
				2125	if (!result) goto failed;
				2126	value = ast2obj_expr(o->v.Yield.value);
				2127	if (!value) goto failed;
				2128	if (PyObject_SetAttrString(result, "value", value) == -1)
				2129	goto failed;
				2130	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2131	break;
				2132	case Compare_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2133	result = PyType_GenericNew(Compare_type, NULL, NULL);
				2134	if (!result) goto failed;
				2135	value = ast2obj_expr(o->v.Compare.left);
				2136	if (!value) goto failed;
				2137	if (PyObject_SetAttrString(result, "left", value) == -1)
				2138	goto failed;
				2139	Py_DECREF(value);
Martin v. Löwis	ce1d5d2	2006-02-26 20:51:25 +0000	[diff] [blame]	2140	{
				2141	int i, n = asdl_seq_LEN(o->v.Compare.ops);
				2142	value = PyList_New(n);
				2143	if (!value) goto failed;
				2144	for(i = 0; i < n; i++)
				2145	PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
				2146	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2147	if (!value) goto failed;
				2148	if (PyObject_SetAttrString(result, "ops", value) == -1)
				2149	goto failed;
				2150	Py_DECREF(value);
				2151	value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr);
				2152	if (!value) goto failed;
				2153	if (PyObject_SetAttrString(result, "comparators", value) == -1)
				2154	goto failed;
				2155	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2156	break;
				2157	case Call_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2158	result = PyType_GenericNew(Call_type, NULL, NULL);
				2159	if (!result) goto failed;
				2160	value = ast2obj_expr(o->v.Call.func);
				2161	if (!value) goto failed;
				2162	if (PyObject_SetAttrString(result, "func", value) == -1)
				2163	goto failed;
				2164	Py_DECREF(value);
				2165	value = ast2obj_list(o->v.Call.args, ast2obj_expr);
				2166	if (!value) goto failed;
				2167	if (PyObject_SetAttrString(result, "args", value) == -1)
				2168	goto failed;
				2169	Py_DECREF(value);
				2170	value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword);
				2171	if (!value) goto failed;
				2172	if (PyObject_SetAttrString(result, "keywords", value) == -1)
				2173	goto failed;
				2174	Py_DECREF(value);
				2175	value = ast2obj_expr(o->v.Call.starargs);
				2176	if (!value) goto failed;
				2177	if (PyObject_SetAttrString(result, "starargs", value) == -1)
				2178	goto failed;
				2179	Py_DECREF(value);
				2180	value = ast2obj_expr(o->v.Call.kwargs);
				2181	if (!value) goto failed;
				2182	if (PyObject_SetAttrString(result, "kwargs", value) == -1)
				2183	goto failed;
				2184	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2185	break;
				2186	case Repr_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2187	result = PyType_GenericNew(Repr_type, NULL, NULL);
				2188	if (!result) goto failed;
				2189	value = ast2obj_expr(o->v.Repr.value);
				2190	if (!value) goto failed;
				2191	if (PyObject_SetAttrString(result, "value", value) == -1)
				2192	goto failed;
				2193	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2194	break;
				2195	case Num_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2196	result = PyType_GenericNew(Num_type, NULL, NULL);
				2197	if (!result) goto failed;
				2198	value = ast2obj_object(o->v.Num.n);
				2199	if (!value) goto failed;
				2200	if (PyObject_SetAttrString(result, "n", value) == -1)
				2201	goto failed;
				2202	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2203	break;
				2204	case Str_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2205	result = PyType_GenericNew(Str_type, NULL, NULL);
				2206	if (!result) goto failed;
				2207	value = ast2obj_string(o->v.Str.s);
				2208	if (!value) goto failed;
				2209	if (PyObject_SetAttrString(result, "s", value) == -1)
				2210	goto failed;
				2211	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2212	break;
				2213	case Attribute_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2214	result = PyType_GenericNew(Attribute_type, NULL, NULL);
				2215	if (!result) goto failed;
				2216	value = ast2obj_expr(o->v.Attribute.value);
				2217	if (!value) goto failed;
				2218	if (PyObject_SetAttrString(result, "value", value) == -1)
				2219	goto failed;
				2220	Py_DECREF(value);
				2221	value = ast2obj_identifier(o->v.Attribute.attr);
				2222	if (!value) goto failed;
				2223	if (PyObject_SetAttrString(result, "attr", value) == -1)
				2224	goto failed;
				2225	Py_DECREF(value);
				2226	value = ast2obj_expr_context(o->v.Attribute.ctx);
				2227	if (!value) goto failed;
				2228	if (PyObject_SetAttrString(result, "ctx", value) == -1)
				2229	goto failed;
				2230	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2231	break;
				2232	case Subscript_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2233	result = PyType_GenericNew(Subscript_type, NULL, NULL);
				2234	if (!result) goto failed;
				2235	value = ast2obj_expr(o->v.Subscript.value);
				2236	if (!value) goto failed;
				2237	if (PyObject_SetAttrString(result, "value", value) == -1)
				2238	goto failed;
				2239	Py_DECREF(value);
				2240	value = ast2obj_slice(o->v.Subscript.slice);
				2241	if (!value) goto failed;
				2242	if (PyObject_SetAttrString(result, "slice", value) == -1)
				2243	goto failed;
				2244	Py_DECREF(value);
				2245	value = ast2obj_expr_context(o->v.Subscript.ctx);
				2246	if (!value) goto failed;
				2247	if (PyObject_SetAttrString(result, "ctx", value) == -1)
				2248	goto failed;
				2249	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2250	break;
				2251	case Name_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2252	result = PyType_GenericNew(Name_type, NULL, NULL);
				2253	if (!result) goto failed;
				2254	value = ast2obj_identifier(o->v.Name.id);
				2255	if (!value) goto failed;
				2256	if (PyObject_SetAttrString(result, "id", value) == -1)
				2257	goto failed;
				2258	Py_DECREF(value);
				2259	value = ast2obj_expr_context(o->v.Name.ctx);
				2260	if (!value) goto failed;
				2261	if (PyObject_SetAttrString(result, "ctx", value) == -1)
				2262	goto failed;
				2263	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2264	break;
				2265	case List_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2266	result = PyType_GenericNew(List_type, NULL, NULL);
				2267	if (!result) goto failed;
				2268	value = ast2obj_list(o->v.List.elts, ast2obj_expr);
				2269	if (!value) goto failed;
				2270	if (PyObject_SetAttrString(result, "elts", value) == -1)
				2271	goto failed;
				2272	Py_DECREF(value);
				2273	value = ast2obj_expr_context(o->v.List.ctx);
				2274	if (!value) goto failed;
				2275	if (PyObject_SetAttrString(result, "ctx", value) == -1)
				2276	goto failed;
				2277	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2278	break;
				2279	case Tuple_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2280	result = PyType_GenericNew(Tuple_type, NULL, NULL);
				2281	if (!result) goto failed;
				2282	value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr);
				2283	if (!value) goto failed;
				2284	if (PyObject_SetAttrString(result, "elts", value) == -1)
				2285	goto failed;
				2286	Py_DECREF(value);
				2287	value = ast2obj_expr_context(o->v.Tuple.ctx);
				2288	if (!value) goto failed;
				2289	if (PyObject_SetAttrString(result, "ctx", value) == -1)
				2290	goto failed;
				2291	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2292	break;
				2293	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2294
				2295	return result;
				2296	failed:
				2297	Py_XDECREF(value);
				2298	Py_XDECREF(result);
				2299	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2300	}
				2301
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2302	PyObject* ast2obj_expr_context(expr_context_ty o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2303	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2304	switch(o) {
				2305	case Load:
				2306	Py_INCREF(Load_singleton);
				2307	return Load_singleton;
				2308	case Store:
				2309	Py_INCREF(Store_singleton);
				2310	return Store_singleton;
				2311	case Del:
				2312	Py_INCREF(Del_singleton);
				2313	return Del_singleton;
				2314	case AugLoad:
				2315	Py_INCREF(AugLoad_singleton);
				2316	return AugLoad_singleton;
				2317	case AugStore:
				2318	Py_INCREF(AugStore_singleton);
				2319	return AugStore_singleton;
				2320	case Param:
				2321	Py_INCREF(Param_singleton);
				2322	return Param_singleton;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2323	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2324	return NULL; /* cannot happen */
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2325	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2326	PyObject*
				2327	ast2obj_slice(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2328	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2329	slice_ty o = (slice_ty)_o;
				2330	PyObject result = NULL, value = NULL;
				2331	if (!o) {
				2332	Py_INCREF(Py_None);
				2333	return Py_None;
				2334	}
				2335
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2336	switch (o->kind) {
				2337	case Ellipsis_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2338	result = PyType_GenericNew(Ellipsis_type, NULL, NULL);
				2339	if (!result) goto failed;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2340	break;
				2341	case Slice_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2342	result = PyType_GenericNew(Slice_type, NULL, NULL);
				2343	if (!result) goto failed;
				2344	value = ast2obj_expr(o->v.Slice.lower);
				2345	if (!value) goto failed;
				2346	if (PyObject_SetAttrString(result, "lower", value) == -1)
				2347	goto failed;
				2348	Py_DECREF(value);
				2349	value = ast2obj_expr(o->v.Slice.upper);
				2350	if (!value) goto failed;
				2351	if (PyObject_SetAttrString(result, "upper", value) == -1)
				2352	goto failed;
				2353	Py_DECREF(value);
				2354	value = ast2obj_expr(o->v.Slice.step);
				2355	if (!value) goto failed;
				2356	if (PyObject_SetAttrString(result, "step", value) == -1)
				2357	goto failed;
				2358	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2359	break;
				2360	case ExtSlice_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2361	result = PyType_GenericNew(ExtSlice_type, NULL, NULL);
				2362	if (!result) goto failed;
				2363	value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice);
				2364	if (!value) goto failed;
				2365	if (PyObject_SetAttrString(result, "dims", value) == -1)
				2366	goto failed;
				2367	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2368	break;
				2369	case Index_kind:
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2370	result = PyType_GenericNew(Index_type, NULL, NULL);
				2371	if (!result) goto failed;
				2372	value = ast2obj_expr(o->v.Index.value);
				2373	if (!value) goto failed;
				2374	if (PyObject_SetAttrString(result, "value", value) == -1)
				2375	goto failed;
				2376	Py_DECREF(value);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2377	break;
				2378	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2379
				2380	return result;
				2381	failed:
				2382	Py_XDECREF(value);
				2383	Py_XDECREF(result);
				2384	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2385	}
				2386
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2387	PyObject* ast2obj_boolop(boolop_ty o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2388	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2389	switch(o) {
				2390	case And:
				2391	Py_INCREF(And_singleton);
				2392	return And_singleton;
				2393	case Or:
				2394	Py_INCREF(Or_singleton);
				2395	return Or_singleton;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2396	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2397	return NULL; /* cannot happen */
				2398	}
				2399	PyObject* ast2obj_operator(operator_ty o)
				2400	{
				2401	switch(o) {
				2402	case Add:
				2403	Py_INCREF(Add_singleton);
				2404	return Add_singleton;
				2405	case Sub:
				2406	Py_INCREF(Sub_singleton);
				2407	return Sub_singleton;
				2408	case Mult:
				2409	Py_INCREF(Mult_singleton);
				2410	return Mult_singleton;
				2411	case Div:
				2412	Py_INCREF(Div_singleton);
				2413	return Div_singleton;
				2414	case Mod:
				2415	Py_INCREF(Mod_singleton);
				2416	return Mod_singleton;
				2417	case Pow:
				2418	Py_INCREF(Pow_singleton);
				2419	return Pow_singleton;
				2420	case LShift:
				2421	Py_INCREF(LShift_singleton);
				2422	return LShift_singleton;
				2423	case RShift:
				2424	Py_INCREF(RShift_singleton);
				2425	return RShift_singleton;
				2426	case BitOr:
				2427	Py_INCREF(BitOr_singleton);
				2428	return BitOr_singleton;
				2429	case BitXor:
				2430	Py_INCREF(BitXor_singleton);
				2431	return BitXor_singleton;
				2432	case BitAnd:
				2433	Py_INCREF(BitAnd_singleton);
				2434	return BitAnd_singleton;
				2435	case FloorDiv:
				2436	Py_INCREF(FloorDiv_singleton);
				2437	return FloorDiv_singleton;
				2438	}
				2439	return NULL; /* cannot happen */
				2440	}
				2441	PyObject* ast2obj_unaryop(unaryop_ty o)
				2442	{
				2443	switch(o) {
				2444	case Invert:
				2445	Py_INCREF(Invert_singleton);
				2446	return Invert_singleton;
				2447	case Not:
				2448	Py_INCREF(Not_singleton);
				2449	return Not_singleton;
				2450	case UAdd:
				2451	Py_INCREF(UAdd_singleton);
				2452	return UAdd_singleton;
				2453	case USub:
				2454	Py_INCREF(USub_singleton);
				2455	return USub_singleton;
				2456	}
				2457	return NULL; /* cannot happen */
				2458	}
				2459	PyObject* ast2obj_cmpop(cmpop_ty o)
				2460	{
				2461	switch(o) {
				2462	case Eq:
				2463	Py_INCREF(Eq_singleton);
				2464	return Eq_singleton;
				2465	case NotEq:
				2466	Py_INCREF(NotEq_singleton);
				2467	return NotEq_singleton;
				2468	case Lt:
				2469	Py_INCREF(Lt_singleton);
				2470	return Lt_singleton;
				2471	case LtE:
				2472	Py_INCREF(LtE_singleton);
				2473	return LtE_singleton;
				2474	case Gt:
				2475	Py_INCREF(Gt_singleton);
				2476	return Gt_singleton;
				2477	case GtE:
				2478	Py_INCREF(GtE_singleton);
				2479	return GtE_singleton;
				2480	case Is:
				2481	Py_INCREF(Is_singleton);
				2482	return Is_singleton;
				2483	case IsNot:
				2484	Py_INCREF(IsNot_singleton);
				2485	return IsNot_singleton;
				2486	case In:
				2487	Py_INCREF(In_singleton);
				2488	return In_singleton;
				2489	case NotIn:
				2490	Py_INCREF(NotIn_singleton);
				2491	return NotIn_singleton;
				2492	}
				2493	return NULL; /* cannot happen */
				2494	}
				2495	PyObject*
				2496	ast2obj_comprehension(void* _o)
				2497	{
				2498	comprehension_ty o = (comprehension_ty)_o;
				2499	PyObject result = NULL, value = NULL;
				2500	if (!o) {
				2501	Py_INCREF(Py_None);
				2502	return Py_None;
				2503	}
				2504
				2505	result = PyType_GenericNew(comprehension_type, NULL, NULL);
				2506	if (!result) return NULL;
				2507	value = ast2obj_expr(o->target);
				2508	if (!value) goto failed;
				2509	if (PyObject_SetAttrString(result, "target", value) == -1)
				2510	goto failed;
				2511	Py_DECREF(value);
				2512	value = ast2obj_expr(o->iter);
				2513	if (!value) goto failed;
				2514	if (PyObject_SetAttrString(result, "iter", value) == -1)
				2515	goto failed;
				2516	Py_DECREF(value);
				2517	value = ast2obj_list(o->ifs, ast2obj_expr);
				2518	if (!value) goto failed;
				2519	if (PyObject_SetAttrString(result, "ifs", value) == -1)
				2520	goto failed;
				2521	Py_DECREF(value);
				2522
				2523	return result;
				2524	failed:
				2525	Py_XDECREF(value);
				2526	Py_XDECREF(result);
				2527	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2528	}
				2529
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2530	PyObject*
				2531	ast2obj_excepthandler(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2532	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2533	excepthandler_ty o = (excepthandler_ty)_o;
				2534	PyObject result = NULL, value = NULL;
				2535	if (!o) {
				2536	Py_INCREF(Py_None);
				2537	return Py_None;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2538	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2539
				2540	result = PyType_GenericNew(excepthandler_type, NULL, NULL);
				2541	if (!result) return NULL;
				2542	value = ast2obj_expr(o->type);
				2543	if (!value) goto failed;
				2544	if (PyObject_SetAttrString(result, "type", value) == -1)
				2545	goto failed;
				2546	Py_DECREF(value);
				2547	value = ast2obj_expr(o->name);
				2548	if (!value) goto failed;
				2549	if (PyObject_SetAttrString(result, "name", value) == -1)
				2550	goto failed;
				2551	Py_DECREF(value);
				2552	value = ast2obj_list(o->body, ast2obj_stmt);
				2553	if (!value) goto failed;
				2554	if (PyObject_SetAttrString(result, "body", value) == -1)
				2555	goto failed;
				2556	Py_DECREF(value);
				2557
				2558	return result;
				2559	failed:
				2560	Py_XDECREF(value);
				2561	Py_XDECREF(result);
				2562	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2563	}
				2564
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2565	PyObject*
				2566	ast2obj_arguments(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2567	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2568	arguments_ty o = (arguments_ty)_o;
				2569	PyObject result = NULL, value = NULL;
				2570	if (!o) {
				2571	Py_INCREF(Py_None);
				2572	return Py_None;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2573	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2574
				2575	result = PyType_GenericNew(arguments_type, NULL, NULL);
				2576	if (!result) return NULL;
				2577	value = ast2obj_list(o->args, ast2obj_expr);
				2578	if (!value) goto failed;
				2579	if (PyObject_SetAttrString(result, "args", value) == -1)
				2580	goto failed;
				2581	Py_DECREF(value);
				2582	value = ast2obj_identifier(o->vararg);
				2583	if (!value) goto failed;
				2584	if (PyObject_SetAttrString(result, "vararg", value) == -1)
				2585	goto failed;
				2586	Py_DECREF(value);
				2587	value = ast2obj_identifier(o->kwarg);
				2588	if (!value) goto failed;
				2589	if (PyObject_SetAttrString(result, "kwarg", value) == -1)
				2590	goto failed;
				2591	Py_DECREF(value);
				2592	value = ast2obj_list(o->defaults, ast2obj_expr);
				2593	if (!value) goto failed;
				2594	if (PyObject_SetAttrString(result, "defaults", value) == -1)
				2595	goto failed;
				2596	Py_DECREF(value);
				2597
				2598	return result;
				2599	failed:
				2600	Py_XDECREF(value);
				2601	Py_XDECREF(result);
				2602	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2603	}
				2604
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2605	PyObject*
				2606	ast2obj_keyword(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2607	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2608	keyword_ty o = (keyword_ty)_o;
				2609	PyObject result = NULL, value = NULL;
				2610	if (!o) {
				2611	Py_INCREF(Py_None);
				2612	return Py_None;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2613	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2614
				2615	result = PyType_GenericNew(keyword_type, NULL, NULL);
				2616	if (!result) return NULL;
				2617	value = ast2obj_identifier(o->arg);
				2618	if (!value) goto failed;
				2619	if (PyObject_SetAttrString(result, "arg", value) == -1)
				2620	goto failed;
				2621	Py_DECREF(value);
				2622	value = ast2obj_expr(o->value);
				2623	if (!value) goto failed;
				2624	if (PyObject_SetAttrString(result, "value", value) == -1)
				2625	goto failed;
				2626	Py_DECREF(value);
				2627
				2628	return result;
				2629	failed:
				2630	Py_XDECREF(value);
				2631	Py_XDECREF(result);
				2632	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2633	}
				2634
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2635	PyObject*
				2636	ast2obj_alias(void* _o)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2637	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2638	alias_ty o = (alias_ty)_o;
				2639	PyObject result = NULL, value = NULL;
				2640	if (!o) {
				2641	Py_INCREF(Py_None);
				2642	return Py_None;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2643	}
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2644
				2645	result = PyType_GenericNew(alias_type, NULL, NULL);
				2646	if (!result) return NULL;
				2647	value = ast2obj_identifier(o->name);
				2648	if (!value) goto failed;
				2649	if (PyObject_SetAttrString(result, "name", value) == -1)
				2650	goto failed;
				2651	Py_DECREF(value);
				2652	value = ast2obj_identifier(o->asname);
				2653	if (!value) goto failed;
				2654	if (PyObject_SetAttrString(result, "asname", value) == -1)
				2655	goto failed;
				2656	Py_DECREF(value);
				2657
				2658	return result;
				2659	failed:
				2660	Py_XDECREF(value);
				2661	Py_XDECREF(result);
				2662	return NULL;
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2663	}
				2664
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2665
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2666
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2667	PyObject* PyAST_mod2obj(mod_ty t)
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2668	{
Martin v. Löwis	bd260da	2006-02-26 19:42:26 +0000	[diff] [blame]	2669	init_types();
				2670	return ast2obj_mod(t);
Jeremy Hylton	3e0055f	2005-10-20 19:59:25 +0000	[diff] [blame]	2671	}
				2672
Neal Norwitz	7b5a604	2005-11-13 19:14:20 +0000	[diff] [blame]	2673