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

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