[Python-checkins] r42584 - in python/trunk: Parser/asdl_c.py Python/Python-ast.c

Mon Feb 27 00:40:22 CET 2006

Author: martin.v.loewis
Date: Mon Feb 27 00:40:20 2006
New Revision: 42584
Modified:
 python/trunk/Parser/asdl_c.py
 python/trunk/Python/Python-ast.c
Log:
Stop generating empty arrays.
Modified: python/trunk/Parser/asdl_c.py
==============================================================================

--- python/trunk/Parser/asdl_c.py	(original)
+++ python/trunk/Parser/asdl_c.py	Mon Feb 27 00:40:20 2006
@@ -353,10 +353,11 @@
 def visitProduct(self, prod, name):
 self.emit("PyTypeObject *%s_type;" % name, 0)
 self.emit("static PyObject* ast2obj_%s(void*);" % name, 0)
- self.emit("char *%s_fields[]={" % name,0)
- for f in prod.fields:
- self.emit('"%s",' % f.name, 1)
- self.emit("};", 0)
+ if prod.fields:
+ self.emit("char *%s_fields[]={" % name,0)
+ for f in prod.fields:
+ self.emit('"%s",' % f.name, 1)
+ self.emit("};", 0)
 
 def visitSum(self, sum, name):
 self.emit("PyTypeObject *%s_type;" % name, 0)
@@ -374,10 +375,11 @@
 
 def visitConstructor(self, cons, name):
 self.emit("PyTypeObject *%s_type;" % cons.name, 0)
- self.emit("char *%s_fields[]={" % cons.name, 0)
- for t in cons.fields:
- self.emit('"%s",' % t.name, 1)
- self.emit("};",0)
+ if cons.fields:
+ self.emit("char *%s_fields[]={" % cons.name, 0)
+ for t in cons.fields:
+ self.emit('"%s",' % t.name, 1)
+ self.emit("};",0)
 
 class PyTypesVisitor(PickleVisitor):
 
@@ -450,8 +452,12 @@
 self.emit("}", 0)
 
 def visitProduct(self, prod, name):
- self.emit('%s_type = make_type("%s", &PyBaseObject_Type, %s_fields, %d);' % 
- (name, name, name, len(prod.fields)), 1)
+ if prod.fields:
+ fields = name.value+"_fields"
+ else:
+ fields = "NULL"
+ self.emit('%s_type = make_type("%s", &PyBaseObject_Type, %s, %d);' % 
+ (name, name, fields, len(prod.fields)), 1)
 
 def visitSum(self, sum, name):
 self.emit('%s_type = make_type("%s", &PyBaseObject_Type, NULL, 0);' % (name, name), 1)
@@ -460,8 +466,12 @@
 self.visitConstructor(t, name, simple)
 
 def visitConstructor(self, cons, name, simple):
- self.emit('%s_type = make_type("%s", %s_type, %s_fields, %d);' % 
- (cons.name, cons.name, name, cons.name, len(cons.fields)), 1)
+ if cons.fields:
+ fields = cons.name.value+"_fields"
+ else:
+ fields = "NULL"
+ self.emit('%s_type = make_type("%s", %s_type, %s, %d);' % 
+ (cons.name, cons.name, name, fields, len(cons.fields)), 1)
 if simple:
 self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" %
 (cons.name, cons.name), 1)
Modified: python/trunk/Python/Python-ast.c
==============================================================================
--- python/trunk/Python/Python-ast.c	(original)
+++ python/trunk/Python/Python-ast.c	Mon Feb 27 00:40:20 2006
@@ -126,14 +126,8 @@
 "value",
 };
 PyTypeObject *Pass_type;
-char *Pass_fields[]={
-};
 PyTypeObject *Break_type;
-char *Break_fields[]={
-};
 PyTypeObject *Continue_type;
-char *Continue_fields[]={
-};
 PyTypeObject *expr_type;
 static PyObject* ast2obj_expr(void*);
 PyTypeObject *BoolOp_type;
@@ -234,28 +228,14 @@
 *AugLoad_singleton, *AugStore_singleton, *Param_singleton;
 static PyObject* ast2obj_expr_context(expr_context_ty);
 PyTypeObject *Load_type;
-char *Load_fields[]={
-};
 PyTypeObject *Store_type;
-char *Store_fields[]={
-};
 PyTypeObject *Del_type;
-char *Del_fields[]={
-};
 PyTypeObject *AugLoad_type;
-char *AugLoad_fields[]={
-};
 PyTypeObject *AugStore_type;
-char *AugStore_fields[]={
-};
 PyTypeObject *Param_type;
-char *Param_fields[]={
-};
 PyTypeObject *slice_type;
 static PyObject* ast2obj_slice(void*);
 PyTypeObject *Ellipsis_type;
-char *Ellipsis_fields[]={
-};
 PyTypeObject *Slice_type;
 char *Slice_fields[]={
 "lower",
@@ -274,11 +254,7 @@
 static PyObject *And_singleton, *Or_singleton;
 static PyObject* ast2obj_boolop(boolop_ty);
 PyTypeObject *And_type;
-char *And_fields[]={
-};
 PyTypeObject *Or_type;
-char *Or_fields[]={
-};
 PyTypeObject *operator_type;
 static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,
 *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton,
@@ -286,92 +262,40 @@
 *FloorDiv_singleton;
 static PyObject* ast2obj_operator(operator_ty);
 PyTypeObject *Add_type;
-char *Add_fields[]={
-};
 PyTypeObject *Sub_type;
-char *Sub_fields[]={
-};
 PyTypeObject *Mult_type;
-char *Mult_fields[]={
-};
 PyTypeObject *Div_type;
-char *Div_fields[]={
-};
 PyTypeObject *Mod_type;
-char *Mod_fields[]={
-};
 PyTypeObject *Pow_type;
-char *Pow_fields[]={
-};
 PyTypeObject *LShift_type;
-char *LShift_fields[]={
-};
 PyTypeObject *RShift_type;
-char *RShift_fields[]={
-};
 PyTypeObject *BitOr_type;
-char *BitOr_fields[]={
-};
 PyTypeObject *BitXor_type;
-char *BitXor_fields[]={
-};
 PyTypeObject *BitAnd_type;
-char *BitAnd_fields[]={
-};
 PyTypeObject *FloorDiv_type;
-char *FloorDiv_fields[]={
-};
 PyTypeObject *unaryop_type;
 static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,
 *USub_singleton;
 static PyObject* ast2obj_unaryop(unaryop_ty);
 PyTypeObject *Invert_type;
-char *Invert_fields[]={
-};
 PyTypeObject *Not_type;
-char *Not_fields[]={
-};
 PyTypeObject *UAdd_type;
-char *UAdd_fields[]={
-};
 PyTypeObject *USub_type;
-char *USub_fields[]={
-};
 PyTypeObject *cmpop_type;
 static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton,
 *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton,
 *NotIn_singleton;
 static PyObject* ast2obj_cmpop(cmpop_ty);
 PyTypeObject *Eq_type;
-char *Eq_fields[]={
-};
 PyTypeObject *NotEq_type;
-char *NotEq_fields[]={
-};
 PyTypeObject *Lt_type;
-char *Lt_fields[]={
-};
 PyTypeObject *LtE_type;
-char *LtE_fields[]={
-};
 PyTypeObject *Gt_type;
-char *Gt_fields[]={
-};
 PyTypeObject *GtE_type;
-char *GtE_fields[]={
-};
 PyTypeObject *Is_type;
-char *Is_fields[]={
-};
 PyTypeObject *IsNot_type;
-char *IsNot_fields[]={
-};
 PyTypeObject *In_type;
-char *In_fields[]={
-};
 PyTypeObject *NotIn_type;
-char *NotIn_fields[]={
-};
 PyTypeObject *comprehension_type;
 static PyObject* ast2obj_comprehension(void*);
 char *comprehension_fields[]={
@@ -498,9 +422,9 @@
 Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);
 Global_type = make_type("Global", stmt_type, Global_fields, 1);
 Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);
- Pass_type = make_type("Pass", stmt_type, Pass_fields, 0);
- Break_type = make_type("Break", stmt_type, Break_fields, 0);
- Continue_type = make_type("Continue", stmt_type, Continue_fields, 0);
+ Pass_type = make_type("Pass", stmt_type, NULL, 0);
+ Break_type = make_type("Break", stmt_type, NULL, 0);
+ Continue_type = make_type("Continue", stmt_type, NULL, 0);
 expr_type = make_type("expr", &PyBaseObject_Type, NULL, 0);
 BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);
 BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);
@@ -523,85 +447,82 @@
 Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);
 expr_context_type = make_type("expr_context", &PyBaseObject_Type, NULL,
 0);
- Load_type = make_type("Load", expr_context_type, Load_fields, 0);
+ Load_type = make_type("Load", expr_context_type, NULL, 0);
 Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);
- Store_type = make_type("Store", expr_context_type, Store_fields, 0);
+ Store_type = make_type("Store", expr_context_type, NULL, 0);
 Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);
- Del_type = make_type("Del", expr_context_type, Del_fields, 0);
+ Del_type = make_type("Del", expr_context_type, NULL, 0);
 Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);
- AugLoad_type = make_type("AugLoad", expr_context_type, AugLoad_fields,
- 0);
+ AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);
 AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);
- AugStore_type = make_type("AugStore", expr_context_type,
- AugStore_fields, 0);
+ AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);
 AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);
- Param_type = make_type("Param", expr_context_type, Param_fields, 0);
+ Param_type = make_type("Param", expr_context_type, NULL, 0);
 Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);
 slice_type = make_type("slice", &PyBaseObject_Type, NULL, 0);
- Ellipsis_type = make_type("Ellipsis", slice_type, Ellipsis_fields, 0);
+ Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0);
 Slice_type = make_type("Slice", slice_type, Slice_fields, 3);
 ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);
 Index_type = make_type("Index", slice_type, Index_fields, 1);
 boolop_type = make_type("boolop", &PyBaseObject_Type, NULL, 0);
- And_type = make_type("And", boolop_type, And_fields, 0);
+ And_type = make_type("And", boolop_type, NULL, 0);
 And_singleton = PyType_GenericNew(And_type, NULL, NULL);
- Or_type = make_type("Or", boolop_type, Or_fields, 0);
+ Or_type = make_type("Or", boolop_type, NULL, 0);
 Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);
 operator_type = make_type("operator", &PyBaseObject_Type, NULL, 0);
- Add_type = make_type("Add", operator_type, Add_fields, 0);
+ Add_type = make_type("Add", operator_type, NULL, 0);
 Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);
- Sub_type = make_type("Sub", operator_type, Sub_fields, 0);
+ Sub_type = make_type("Sub", operator_type, NULL, 0);
 Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);
- Mult_type = make_type("Mult", operator_type, Mult_fields, 0);
+ Mult_type = make_type("Mult", operator_type, NULL, 0);
 Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);
- Div_type = make_type("Div", operator_type, Div_fields, 0);
+ Div_type = make_type("Div", operator_type, NULL, 0);
 Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);
- Mod_type = make_type("Mod", operator_type, Mod_fields, 0);
+ Mod_type = make_type("Mod", operator_type, NULL, 0);
 Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);
- Pow_type = make_type("Pow", operator_type, Pow_fields, 0);
+ Pow_type = make_type("Pow", operator_type, NULL, 0);
 Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);
- LShift_type = make_type("LShift", operator_type, LShift_fields, 0);
+ LShift_type = make_type("LShift", operator_type, NULL, 0);
 LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);
- RShift_type = make_type("RShift", operator_type, RShift_fields, 0);
+ RShift_type = make_type("RShift", operator_type, NULL, 0);
 RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);
- BitOr_type = make_type("BitOr", operator_type, BitOr_fields, 0);
+ BitOr_type = make_type("BitOr", operator_type, NULL, 0);
 BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);
- BitXor_type = make_type("BitXor", operator_type, BitXor_fields, 0);
+ BitXor_type = make_type("BitXor", operator_type, NULL, 0);
 BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);
- BitAnd_type = make_type("BitAnd", operator_type, BitAnd_fields, 0);
+ BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);
 BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);
- FloorDiv_type = make_type("FloorDiv", operator_type, FloorDiv_fields,
- 0);
+ FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);
 FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);
 unaryop_type = make_type("unaryop", &PyBaseObject_Type, NULL, 0);
- Invert_type = make_type("Invert", unaryop_type, Invert_fields, 0);
+ Invert_type = make_type("Invert", unaryop_type, NULL, 0);
 Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);
- Not_type = make_type("Not", unaryop_type, Not_fields, 0);
+ Not_type = make_type("Not", unaryop_type, NULL, 0);
 Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);
- UAdd_type = make_type("UAdd", unaryop_type, UAdd_fields, 0);
+ UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);
 UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);
- USub_type = make_type("USub", unaryop_type, USub_fields, 0);
+ USub_type = make_type("USub", unaryop_type, NULL, 0);
 USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);
 cmpop_type = make_type("cmpop", &PyBaseObject_Type, NULL, 0);
- Eq_type = make_type("Eq", cmpop_type, Eq_fields, 0);
+ Eq_type = make_type("Eq", cmpop_type, NULL, 0);
 Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);
- NotEq_type = make_type("NotEq", cmpop_type, NotEq_fields, 0);
+ NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);
 NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);
- Lt_type = make_type("Lt", cmpop_type, Lt_fields, 0);
+ Lt_type = make_type("Lt", cmpop_type, NULL, 0);
 Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);
- LtE_type = make_type("LtE", cmpop_type, LtE_fields, 0);
+ LtE_type = make_type("LtE", cmpop_type, NULL, 0);
 LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);
- Gt_type = make_type("Gt", cmpop_type, Gt_fields, 0);
+ Gt_type = make_type("Gt", cmpop_type, NULL, 0);
 Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);
- GtE_type = make_type("GtE", cmpop_type, GtE_fields, 0);
+ GtE_type = make_type("GtE", cmpop_type, NULL, 0);
 GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);
- Is_type = make_type("Is", cmpop_type, Is_fields, 0);
+ Is_type = make_type("Is", cmpop_type, NULL, 0);
 Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);
- IsNot_type = make_type("IsNot", cmpop_type, IsNot_fields, 0);
+ IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);
 IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);
- In_type = make_type("In", cmpop_type, In_fields, 0);
+ In_type = make_type("In", cmpop_type, NULL, 0);
 In_singleton = PyType_GenericNew(In_type, NULL, NULL);
- NotIn_type = make_type("NotIn", cmpop_type, NotIn_fields, 0);
+ NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);
 NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);
 comprehension_type = make_type("comprehension", &PyBaseObject_Type,
 comprehension_fields, 3);
