[Python-checkins] r63857 - in python/branches/tlee-ast-optimize: Include/compile.h Include/optimize.h Python/bltinmodule.c Python/compile.c Python/optimize.c Python/pythonrun.c

Sun Jun 1 18:29:03 CEST 2008

Author: thomas.lee
Date: Sun Jun 1 18:29:02 2008
New Revision: 63857
Log:
Reverting earlier changes. Need to tread a little more carefully here.
Modified:
 python/branches/tlee-ast-optimize/Include/compile.h
 python/branches/tlee-ast-optimize/Include/optimize.h
 python/branches/tlee-ast-optimize/Python/bltinmodule.c
 python/branches/tlee-ast-optimize/Python/compile.c
 python/branches/tlee-ast-optimize/Python/optimize.c
 python/branches/tlee-ast-optimize/Python/pythonrun.c
Modified: python/branches/tlee-ast-optimize/Include/compile.h
==============================================================================

--- python/branches/tlee-ast-optimize/Include/compile.h	(original)
+++ python/branches/tlee-ast-optimize/Include/compile.h	Sun Jun 1 18:29:02 2008
@@ -32,8 +32,6 @@
 PyAPI_FUNC(PyCodeObject *) PyAST_Compile(struct _mod *, const char *,
 					PyCompilerFlags *, PyArena *);
 PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(struct _mod *, const char *);
-PyAPI_FUNC(int) PyAST_BuildSymbolInfo(struct _mod *, PyFutureFeatures**,
- struct symtable**, const char*, PyCompilerFlags*);
 
 #define ERR_LATE_FUTURE \
 "from __future__ imports must occur at the beginning of the file"
Modified: python/branches/tlee-ast-optimize/Include/optimize.h
==============================================================================
--- python/branches/tlee-ast-optimize/Include/optimize.h	(original)
+++ python/branches/tlee-ast-optimize/Include/optimize.h	Sun Jun 1 18:29:02 2008
@@ -5,8 +5,7 @@
 extern "C" {
 #endif
 
-PyAPI_FUNC(int) PyAST_Optimize(mod_ty* mod_ptr, struct symtable* st,
- PyArena* arena);
+PyAPI_FUNC(int) PyAST_Optimize(mod_ty* mod_ptr, PyArena* arena);
 
 #ifdef __cplusplus
 };
Modified: python/branches/tlee-ast-optimize/Python/bltinmodule.c
==============================================================================
--- python/branches/tlee-ast-optimize/Python/bltinmodule.c	(original)
+++ python/branches/tlee-ast-optimize/Python/bltinmodule.c	Sun Jun 1 18:29:02 2008
@@ -6,7 +6,6 @@
 #include "node.h"
 #include "code.h"
 #include "eval.h"
-#include "symtable.h"
 #include "optimize.h"
 
 #include <ctype.h>
@@ -516,8 +515,6 @@
 		else {
 			PyArena *arena;
 			mod_ty mod;
- struct symtable* st;
- PyFutureFeatures* future;
 
 			arena = PyArena_New();
 			mod = PyAST_obj2mod(cmd, arena, mode);
@@ -525,15 +522,9 @@
 				PyArena_Free(arena);
 				return NULL;
 			}
- if (!PyAST_BuildSymbolInfo(mod, &future, &st, filename, &cf)) {
- PyArena_Free(arena);
- return NULL;
- }
 if (!(supplied_flags & PyCF_NO_OPTIMIZE)) {
- if (!PyAST_Optimize(&mod, st, arena)) {
+ if (!PyAST_Optimize(&mod, arena)) {
 PyArena_Free(arena);
- PySymtable_Free(st);
- PyObject_Free(future);
 return NULL;
 }
 }
Modified: python/branches/tlee-ast-optimize/Python/compile.c
==============================================================================
--- python/branches/tlee-ast-optimize/Python/compile.c	(original)
+++ python/branches/tlee-ast-optimize/Python/compile.c	Sun Jun 1 18:29:02 2008
@@ -180,31 +180,6 @@
 static PyCodeObject *assemble(struct compiler *, int addNone);
 static PyObject *__doc__;
 
-int
-PyAST_BuildSymbolInfo(mod_ty mod, PyFutureFeatures** f, struct symtable** st,
- const char* filename, PyCompilerFlags* cf)
-{
- int merged;
-
- *f = PyFuture_FromAST(mod, filename);
- if (*f == NULL)
- return 0;
-
- merged = (*f)->ff_features | (cf ? cf->cf_flags : 0);
- (*f)->ff_features = merged;
-
- *st = PySymtable_Build(mod, filename, *f);
- if (*st == NULL) {
- PyObject_Free(*st);
- return 0;
- }
-
- if (cf != NULL)
- cf->cf_flags = merged;
-
- return 1;
-}
-
 PyObject *
 _Py_Mangle(PyObject *privateobj, PyObject *ident)
 {
@@ -272,6 +247,7 @@
 	struct compiler c;
 	PyCodeObject *co = NULL;
 	PyCompilerFlags local_flags;
+	int merged;
 
 	if (!__doc__) {
 		__doc__ = PyBytes_InternFromString("__doc__");
@@ -283,13 +259,25 @@
 		return NULL;
 	c.c_filename = filename;
 	c.c_arena = arena;
+	c.c_future = PyFuture_FromAST(mod, filename);
+	if (c.c_future == NULL)
+		goto finally;
 	if (!flags) {
 		local_flags.cf_flags = 0;
 		flags = &local_flags;
 	}
- if (!PyAST_BuildSymbolInfo(mod, &c.c_future, &c.c_st, filename, flags))
- goto finally;
- c.c_flags = flags;
+	merged = c.c_future->ff_features | flags->cf_flags;
+	c.c_future->ff_features = merged;
+	flags->cf_flags = merged;
+	c.c_flags = flags;
+	c.c_nestlevel = 0;
+
+	c.c_st = PySymtable_Build(mod, filename, c.c_future);
+	if (c.c_st == NULL) {
+		if (!PyErr_Occurred())
+			PyErr_SetString(PyExc_SystemError, "no symtable");
+		goto finally;
+	}
 
 	/* XXX initialize to NULL for now, need to handle */
 	c.c_encoding = NULL;
@@ -312,15 +300,8 @@
 		return NULL;
 	mod = PyAST_FromNode(n, NULL, filename, arena);
 	if (mod != NULL) {
- PyFutureFeatures* future;
- struct symtable* st;
-
- if (PyAST_BuildSymbolInfo(mod, &future, &st, filename, NULL)) {
- if (PyAST_Optimize(&mod, st, arena)) {
- co = PyAST_Compile(mod, filename, NULL, arena);
- }
- PyObject_Free(future);
- PySymtable_Free(st);
+ if (PyAST_Optimize(&mod, arena)) {
+ co = PyAST_Compile(mod, filename, NULL, arena);
 }
 }
 	PyArena_Free(arena);
@@ -330,10 +311,10 @@
 static void
 compiler_free(struct compiler *c)
 {
- if (c->c_st != NULL)
- PySymtable_Free(c->c_st);
- if (c->c_future)
- PyObject_Free(c->c_future);
+	if (c->c_st)
+		PySymtable_Free(c->c_st);
+	if (c->c_future)
+		PyObject_Free(c->c_future);
 	Py_DECREF(c->c_stack);
 }
 
Modified: python/branches/tlee-ast-optimize/Python/optimize.c
==============================================================================
--- python/branches/tlee-ast-optimize/Python/optimize.c	(original)
+++ python/branches/tlee-ast-optimize/Python/optimize.c	Sun Jun 1 18:29:02 2008
@@ -4,22 +4,14 @@
 #include "pyerrors.h"
 #include "node.h"
 #include "ast.h"
-#include "symtable.h"
 
-static int optimize_expr(expr_ty* expr_ptr, PySTEntryObject* ste,
- PyArena* arena);
-static int optimize_stmt(stmt_ty* stmt_ptr, PySTEntryObject* ste,
- PyArena* arena);
-static int optimize_comprehension(comprehension_ty* comp_ptr,
- PySTEntryObject* ste, PyArena* arena);
-static int optimize_excepthandler(excepthandler_ty* exc_ptr,
- PySTEntryObject* ste, PyArena* arena);
-static int optimize_keyword(keyword_ty* kwd_ptr, PySTEntryObject* ste,
- PyArena* arena);
-static int optimize_arguments(arguments_ty* args_ptr, PySTEntryObject* ste,
- PyArena* arena);
-static int optimize_slice(slice_ty* slice_ptr, PySTEntryObject* ste,
- PyArena* arena);
+static int optimize_expr(expr_ty* expr_ptr, PyArena* arena);
+static int optimize_stmt(stmt_ty* stmt_ptr, PyArena* arena);
+static int optimize_comprehension(comprehension_ty* comp_ptr, PyArena* arena);
+static int optimize_excepthandler(excepthandler_ty* exc_ptr, PyArena* arena);
+static int optimize_keyword(keyword_ty* kwd_ptr, PyArena* arena);
+static int optimize_arguments(arguments_ty* args_ptr, PyArena* arena);
+static int optimize_slice(slice_ty* slice_ptr, PyArena* arena);
 
 /**
 * Determine the constant value of a given expression. It's assumed that
@@ -141,12 +133,12 @@
 * Optimize a sequence of expressions.
 */
 static int
-optimize_expr_seq(asdl_seq** seq_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_expr_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++)
- if (!optimize_expr((expr_ty*)&asdl_seq_GET(seq, n), ste, arena))
+ if (!optimize_expr((expr_ty*)&asdl_seq_GET(seq, n), arena))
 return 0;
 return 1;
 }
@@ -194,8 +186,7 @@
 * Replaces the AST node at `n' with a Pass() node.
 */
 static asdl_seq*
-_asdl_seq_replace_with_pass(asdl_seq* seq, int n, int lineno, int col_offset,
- PyArena* arena)
+_asdl_seq_replace_with_pass(asdl_seq* seq, int n, int lineno, int col_offset, PyArena* arena)
 {
 stmt_ty pass = Pass(lineno, col_offset, arena);
 if (pass == NULL)
@@ -208,13 +199,13 @@
 * Optimize a sequence of statements.
 */
 static int
-optimize_stmt_seq(asdl_seq** seq_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_stmt_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++) {
 stmt_ty stmt = asdl_seq_GET(seq, n);
- if (!optimize_stmt((stmt_ty*)&asdl_seq_GET(seq, n), ste, arena))
+ if (!optimize_stmt((stmt_ty*)&asdl_seq_GET(seq, n), arena))
 return 0;
 
 if (stmt->kind == If_kind) {
@@ -252,59 +243,57 @@
 }
 
 static int
-optimize_comprehension_seq(asdl_seq** seq_ptr, PySTEntryObject* ste,
- PyArena* arena)
+optimize_comprehension_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++) {
 comprehension_ty* comp;
 comp = (comprehension_ty*)&asdl_seq_GET(seq, n);
- if (!optimize_comprehension(comp, ste, arena))
+ if (!optimize_comprehension(comp, arena))
 return 0;
 }
 return 1;
 }
 
 static int
-optimize_excepthandler_seq(asdl_seq** seq_ptr, PySTEntryObject* ste,
- PyArena* arena)
+optimize_excepthandler_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++) {
 excepthandler_ty* excepthandler;
 excepthandler = (excepthandler_ty*)&asdl_seq_GET(seq, n);
- if (!optimize_excepthandler(excepthandler, ste, arena))
+ if (!optimize_excepthandler(excepthandler, arena))
 return 0;
 }
 return 1;
 }
 
 static int
-optimize_keyword_seq(asdl_seq** seq_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_keyword_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++)
- if (!optimize_keyword((keyword_ty*)&asdl_seq_GET(seq, n), ste, arena))
+ if (!optimize_keyword((keyword_ty*)&asdl_seq_GET(seq, n), arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_slice_seq(asdl_seq** seq_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_slice_seq(asdl_seq** seq_ptr, PyArena* arena)
 {
 int n;
 asdl_seq* seq = *seq_ptr;
 for (n = 0; n < asdl_seq_LEN(seq); n++)
- if (!optimize_slice((slice_ty*)&asdl_seq_GET(seq, n), ste, arena))
+ if (!optimize_slice((slice_ty*)&asdl_seq_GET(seq, n), arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_mod(mod_ty* mod_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_mod(mod_ty* mod_ptr, PyArena* arena)
 {
 asdl_seq** body;
 mod_ty mod = *mod_ptr;
@@ -327,7 +316,7 @@
 }
 case Expression_kind:
 {
- return optimize_expr(&mod->v.Expression.body, ste, arena);
+ return optimize_expr(&mod->v.Expression.body, arena);
 }
 default:
 PyErr_Format(PyExc_ValueError, "unknown mod_ty kind: %d",
@@ -335,28 +324,28 @@
 return 0;
 };
 
- return optimize_stmt_seq(body, ste, arena);
+ return optimize_stmt_seq(body, arena);
 }
 
 static int
-optimize_bool_op(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_bool_op(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr_seq(&expr->v.BoolOp.values, ste, arena))
+ if (!optimize_expr_seq(&expr->v.BoolOp.values, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_bin_op(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_bin_op(expr_ty* expr_ptr, PyArena* arena)
 {
 PyObject* left;
 PyObject* right;
 expr_ty expr = *expr_ptr;
 
- if (!optimize_expr(&expr->v.BinOp.left, ste, arena))
+ if (!optimize_expr(&expr->v.BinOp.left, arena))
 return 0;
- if (!optimize_expr(&expr->v.BinOp.right, ste, arena))
+ if (!optimize_expr(&expr->v.BinOp.right, arena))
 return 0;
 
 /* 
@@ -483,11 +472,11 @@
 }
 
 static int
-optimize_unary_op(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_unary_op(expr_ty* expr_ptr, PyArena* arena)
 {
 PyObject* operand;
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.UnaryOp.operand, ste, arena))
+ if (!optimize_expr(&expr->v.UnaryOp.operand, arena))
 return 0;
 operand = _expr_constant_value(expr->v.UnaryOp.operand);
 if (operand != NULL) {
@@ -548,82 +537,76 @@
 }
 
 static int
-optimize_lambda(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_lambda(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- /* XXX: do we need to look up ste again? */
- if (!optimize_expr(&expr->v.Lambda.body, ste, arena))
+ if (!optimize_expr(&expr->v.Lambda.body, arena))
 return 0;
 return 1;
 }
 
-static int optimize_if_exp(expr_ty* expr_ptr, PySTEntryObject* ste,
- PyArena* arena) {
+static int optimize_if_exp(expr_ty* expr_ptr, PyArena* arena) {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.IfExp.test, ste, arena))
+ if (!optimize_expr(&expr->v.IfExp.test, arena))
 return 0;
- if (!optimize_expr(&expr->v.IfExp.body, ste, arena))
+ if (!optimize_expr(&expr->v.IfExp.body, arena))
 return 0;
- if (!optimize_expr(&expr->v.IfExp.orelse, ste, arena))
+ if (!optimize_expr(&expr->v.IfExp.orelse, arena))
 return 0;
 return 1;
 }
 
-static int optimize_dict(expr_ty* expr_ptr, PySTEntryObject* ste,
- PyArena* arena)
-{
+static int optimize_dict(expr_ty* expr_ptr, PyArena* arena) {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr_seq(&expr->v.Dict.keys, ste, arena))
+ if (!optimize_expr_seq(&expr->v.Dict.keys, arena))
 return 0;
- if (!optimize_expr_seq(&expr->v.Dict.values, ste, arena))
+ if (!optimize_expr_seq(&expr->v.Dict.values, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_comprehension(comprehension_ty* comp_ptr, PySTEntryObject* ste,
- PyArena* arena)
+optimize_comprehension(comprehension_ty* comp_ptr, PyArena* arena)
 {
 comprehension_ty comp = *comp_ptr;
- if (!optimize_expr(&comp->target, ste, arena))
+ if (!optimize_expr(&comp->target, arena))
 return 0;
- if (!optimize_expr(&comp->iter, ste, arena))
+ if (!optimize_expr(&comp->iter, arena))
 return 0;
- if (!optimize_expr_seq(&comp->ifs, ste, arena))
+ if (!optimize_expr_seq(&comp->ifs, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_list_comp(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_list_comp(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.ListComp.elt, ste, arena))
+ if (!optimize_expr(&expr->v.ListComp.elt, arena))
 return 0;
- if (!optimize_comprehension_seq(&expr->v.ListComp.generators, ste, arena))
+ if (!optimize_comprehension_seq(&expr->v.ListComp.generators, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_generator_exp(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_generator_exp(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.GeneratorExp.elt, ste, arena))
+ if (!optimize_expr(&expr->v.GeneratorExp.elt, arena))
 return 0;
- if (!optimize_comprehension_seq(&expr->v.GeneratorExp.generators, ste,
- arena))
+ if (!optimize_comprehension_seq(&expr->v.GeneratorExp.generators, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_yield(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_yield(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
 if (expr->v.Yield.value != NULL) {
 expr_ty value;
- if (!optimize_expr(&expr->v.Yield.value, ste, arena))
+ if (!optimize_expr(&expr->v.Yield.value, arena))
 return 0;
 value = expr->v.Yield.value;
 if (value->kind == Const_kind && value->v.Const.value == Py_None)
@@ -633,101 +616,100 @@
 }
 
 static int
-optimize_compare(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_compare(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.Compare.left, ste, arena))
+ if (!optimize_expr(&expr->v.Compare.left, arena))
 return 0;
- if (!optimize_expr_seq(&expr->v.Compare.comparators, ste, arena))
+ if (!optimize_expr_seq(&expr->v.Compare.comparators, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_keyword(keyword_ty* keyword_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_keyword(keyword_ty* keyword_ptr, PyArena* arena)
 {
 keyword_ty keyword = *keyword_ptr;
- if (!optimize_expr(&keyword->value, ste, arena))
+ if (!optimize_expr(&keyword->value, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_arguments(arguments_ty* args_ptr, PySTEntryObject* ste,
- PyArena* arena)
+optimize_arguments(arguments_ty* args_ptr, PyArena* arena)
 {
 arguments_ty args = *args_ptr;
- if (!optimize_expr_seq(&args->args, ste, arena))
+ if (!optimize_expr_seq(&args->args, arena))
 return 0;
- if (!optimize_expr_seq(&args->defaults, ste, arena))
+ if (!optimize_expr_seq(&args->defaults, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_call(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_call(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.Call.func, ste, arena))
+ if (!optimize_expr(&expr->v.Call.func, arena))
 return 0;
- if (!optimize_expr_seq(&expr->v.Call.args, ste, arena))
+ if (!optimize_expr_seq(&expr->v.Call.args, arena))
 return 0;
- if (!optimize_keyword_seq(&expr->v.Call.keywords, ste, arena))
+ if (!optimize_keyword_seq(&expr->v.Call.keywords, arena))
 return 0;
 if (expr->v.Call.starargs != NULL)
- if (!optimize_expr(&expr->v.Call.starargs, ste, arena))
+ if (!optimize_expr(&expr->v.Call.starargs, arena))
 return 0;
 if (expr->v.Call.kwargs != NULL)
- if (!optimize_expr(&expr->v.Call.kwargs, ste, arena))
+ if (!optimize_expr(&expr->v.Call.kwargs, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_repr(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_repr(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.Repr.value, ste, arena))
+ if (!optimize_expr(&expr->v.Repr.value, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_attribute(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_attribute(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.Attribute.value, ste, arena))
+ if (!optimize_expr(&expr->v.Attribute.value, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_slice(slice_ty* slice_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_slice(slice_ty* slice_ptr, PyArena* arena)
 {
 slice_ty slice = *slice_ptr;
 switch (slice->kind) {
 case Slice_kind:
 {
 if (slice->v.Slice.lower != NULL)
- if (!optimize_expr(&slice->v.Slice.lower, ste, arena))
+ if (!optimize_expr(&slice->v.Slice.lower, arena))
 return 0;
 if (slice->v.Slice.upper != NULL)
- if (!optimize_expr(&slice->v.Slice.upper, ste, arena))
+ if (!optimize_expr(&slice->v.Slice.upper, arena))
 return 0;
 if (slice->v.Slice.step != NULL)
- if (!optimize_expr(&slice->v.Slice.step, ste, arena))
+ if (!optimize_expr(&slice->v.Slice.step, arena))
 return 0;
 break;
 }
 case ExtSlice_kind:
 {
- if (!optimize_slice_seq(&slice->v.ExtSlice.dims, ste, arena))
+ if (!optimize_slice_seq(&slice->v.ExtSlice.dims, arena))
 return 0;
 break;
 }
 case Index_kind:
 {
- if (!optimize_expr(&slice->v.Index.value, ste, arena))
+ if (!optimize_expr(&slice->v.Index.value, arena))
 return 0;
 break;
 }
@@ -744,21 +726,21 @@
 }
 
 static int
-optimize_subscript(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_subscript(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr(&expr->v.Subscript.value, ste, arena))
+ if (!optimize_expr(&expr->v.Subscript.value, arena))
 return 0;
- if (!optimize_slice(&expr->v.Subscript.slice, ste, arena))
+ if (!optimize_slice(&expr->v.Subscript.slice, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_tuple(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_tuple(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
- if (!optimize_expr_seq(&expr->v.Tuple.elts, ste, arena))
+ if (!optimize_expr_seq(&expr->v.Tuple.elts, arena))
 return 0;
 
 if (_is_sequence_of_constants(expr->v.Tuple.elts)) {
@@ -774,7 +756,7 @@
 }
 
 static int
-optimize_name(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_name(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
 const char* id = PyString_AS_STRING(expr->v.Name.id);
@@ -801,77 +783,77 @@
 }
 
 static int
-optimize_expr(expr_ty* expr_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_expr(expr_ty* expr_ptr, PyArena* arena)
 {
 expr_ty expr = *expr_ptr;
 switch (expr->kind) {
 case BoolOp_kind:
 {
- return optimize_bool_op(expr_ptr, ste, arena);
+ return optimize_bool_op(expr_ptr, arena);
 }
 case BinOp_kind:
 {
- return optimize_bin_op(expr_ptr, ste, arena);
+ return optimize_bin_op(expr_ptr, arena);
 }
 case UnaryOp_kind:
 {
- return optimize_unary_op(expr_ptr, ste, arena);
+ return optimize_unary_op(expr_ptr, arena);
 }
 case Lambda_kind:
 {
- return optimize_lambda(expr_ptr, ste, arena);
+ return optimize_lambda(expr_ptr, arena);
 }
 case IfExp_kind:
 {
- return optimize_if_exp(expr_ptr, ste, arena);
+ return optimize_if_exp(expr_ptr, arena);
 }
 case Dict_kind:
 {
- return optimize_dict(expr_ptr, ste, arena);
+ return optimize_dict(expr_ptr, arena);
 }
 case ListComp_kind:
 {
- return optimize_list_comp(expr_ptr, ste, arena);
+ return optimize_list_comp(expr_ptr, arena);
 }
 case GeneratorExp_kind:
 {
- return optimize_generator_exp(expr_ptr, ste, arena);
+ return optimize_generator_exp(expr_ptr, arena);
 }
 case Yield_kind:
 {
- return optimize_yield(expr_ptr, ste, arena);
+ return optimize_yield(expr_ptr, arena);
 }
 case Compare_kind:
 {
- return optimize_compare(expr_ptr, ste, arena);
+ return optimize_compare(expr_ptr, arena);
 }
 case Call_kind:
 {
- return optimize_call(expr_ptr, ste, arena);
+ return optimize_call(expr_ptr, arena);
 }
 case Repr_kind:
 {
- return optimize_repr(expr_ptr, ste, arena);
+ return optimize_repr(expr_ptr, arena);
 }
 case Attribute_kind:
 {
- return optimize_attribute(expr_ptr, ste, arena);
+ return optimize_attribute(expr_ptr, arena);
 }
 case Subscript_kind:
 {
- return optimize_subscript(expr_ptr, ste, arena);
+ return optimize_subscript(expr_ptr, arena);
 }
 case List_kind:
 {
- return optimize_expr_seq(&expr->v.List.elts, ste, arena);
+ return optimize_expr_seq(&expr->v.List.elts, arena);
 }
 case Tuple_kind:
 {
- return optimize_tuple(expr_ptr, ste, arena);
+ return optimize_tuple(expr_ptr, arena);
 }
 case Name_kind:
 {
- return optimize_name(expr_ptr, ste, arena);
+ return optimize_name(expr_ptr, arena);
 }
 case Num_kind:
 case Str_kind:
@@ -887,38 +869,38 @@
 }
 
 static int
-optimize_function_def(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_function_def(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_arguments(&stmt->v.FunctionDef.args, ste, arena))
+ if (!optimize_arguments(&stmt->v.FunctionDef.args, arena))
 return 0;
- if (!optimize_expr_seq(&stmt->v.FunctionDef.decorator_list, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.FunctionDef.decorator_list, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.FunctionDef.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.FunctionDef.body, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_class_def(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_class_def(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr_seq(&stmt->v.ClassDef.bases, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.ClassDef.bases, arena))
 return 0;
- if (!optimize_expr_seq(&stmt->v.ClassDef.decorator_list, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.ClassDef.decorator_list, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.ClassDef.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.ClassDef.body, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_return(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_return(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
 if (stmt->v.Return.value != NULL) {
 expr_ty value;
- if (!optimize_expr(&stmt->v.Return.value, ste, arena))
+ if (!optimize_expr(&stmt->v.Return.value, arena))
 return 0;
 value = stmt->v.Return.value;
 if (value->kind == Const_kind && value->v.Const.value == Py_None)
@@ -928,87 +910,87 @@
 }
 
 static int
-optimize_delete(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_delete(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr_seq(&stmt->v.Delete.targets, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.Delete.targets, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_assign(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_assign(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr_seq(&stmt->v.Assign.targets, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.Assign.targets, arena))
 return 0;
- if (!optimize_expr(&stmt->v.Assign.value, ste, arena))
+ if (!optimize_expr(&stmt->v.Assign.value, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_aug_assign(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_aug_assign(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.AugAssign.target, ste, arena))
+ if (!optimize_expr(&stmt->v.AugAssign.target, arena))
 return 0;
- if (!optimize_expr(&stmt->v.AugAssign.value, ste, arena))
+ if (!optimize_expr(&stmt->v.AugAssign.value, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_print(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_print(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
 
 if (stmt->v.Print.dest != NULL)
- if (!optimize_expr(&stmt->v.Print.dest, ste, arena))
+ if (!optimize_expr(&stmt->v.Print.dest, arena))
 return 0;
- if (!optimize_expr_seq(&stmt->v.Print.values, ste, arena))
+ if (!optimize_expr_seq(&stmt->v.Print.values, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_for(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_for(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.For.target, ste, arena))
+ if (!optimize_expr(&stmt->v.For.target, arena))
 return 0;
- if (!optimize_expr(&stmt->v.For.iter, ste, arena))
+ if (!optimize_expr(&stmt->v.For.iter, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.For.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.For.body, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.For.orelse, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.For.orelse, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_while(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_while(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.While.test, ste, arena))
+ if (!optimize_expr(&stmt->v.While.test, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.While.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.While.body, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.While.orelse, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.While.orelse, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_if(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_if(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
 
- if (!optimize_expr(&stmt->v.If.test, ste, arena))
+ if (!optimize_expr(&stmt->v.If.test, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.If.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.If.body, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.If.orelse, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.If.orelse, arena))
 return 0;
 
 if (stmt->v.If.test->kind == UnaryOp_kind &&
@@ -1038,187 +1020,174 @@
 }
 
 static int
-optimize_with(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_with(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.With.context_expr, ste, arena))
+ if (!optimize_expr(&stmt->v.With.context_expr, arena))
 return 0;
 if (stmt->v.With.optional_vars != NULL)
- if (!optimize_expr(&stmt->v.With.optional_vars, ste, arena))
+ if (!optimize_expr(&stmt->v.With.optional_vars, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.With.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.With.body, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_raise(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_raise(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
 if (stmt->v.Raise.type != NULL)
- if (!optimize_expr(&stmt->v.Raise.type, ste, arena))
+ if (!optimize_expr(&stmt->v.Raise.type, arena))
 return 0;
 if (stmt->v.Raise.inst != NULL)
- if (!optimize_expr(&stmt->v.Raise.inst, ste, arena))
+ if (!optimize_expr(&stmt->v.Raise.inst, arena))
 return 0;
 if (stmt->v.Raise.tback != NULL)
- if (!optimize_expr(&stmt->v.Raise.tback, ste, arena))
+ if (!optimize_expr(&stmt->v.Raise.tback, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_excepthandler(excepthandler_ty* exc_ptr, PySTEntryObject* ste,
- PyArena* arena)
+optimize_excepthandler(excepthandler_ty* exc_ptr, PyArena* arena)
 {
 excepthandler_ty exc = *exc_ptr;
 if (exc->v.ExceptHandler.type != NULL)
- if (!optimize_expr(&exc->v.ExceptHandler.type, ste, arena))
+ if (!optimize_expr(&exc->v.ExceptHandler.type, arena))
 return 0;
 if (exc->v.ExceptHandler.name != NULL)
- if (!optimize_expr(&exc->v.ExceptHandler.name, ste, arena))
+ if (!optimize_expr(&exc->v.ExceptHandler.name, arena))
 return 0;
- if (!optimize_stmt_seq(&exc->v.ExceptHandler.body, ste, arena))
+ if (!optimize_stmt_seq(&exc->v.ExceptHandler.body, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_try_except(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_try_except(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_stmt_seq(&stmt->v.TryExcept.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.TryExcept.body, arena))
 return 0;
- if (!optimize_excepthandler_seq(&stmt->v.TryExcept.handlers, ste, arena))
+ if (!optimize_excepthandler_seq(&stmt->v.TryExcept.handlers, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.TryExcept.orelse, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.TryExcept.orelse, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_try_finally(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_try_finally(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_stmt_seq(&stmt->v.TryFinally.body, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.TryFinally.body, arena))
 return 0;
- if (!optimize_stmt_seq(&stmt->v.TryFinally.finalbody, ste, arena))
+ if (!optimize_stmt_seq(&stmt->v.TryFinally.finalbody, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_assert(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_assert(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.Assert.test, ste, arena))
+ if (!optimize_expr(&stmt->v.Assert.test, arena))
 return 0;
 if (stmt->v.Assert.msg != NULL)
- if (!optimize_expr(&stmt->v.Assert.msg, ste, arena))
+ if (!optimize_expr(&stmt->v.Assert.msg, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_exec(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_exec(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
- if (!optimize_expr(&stmt->v.Exec.body, ste, arena))
+ if (!optimize_expr(&stmt->v.Exec.body, arena))
 return 0;
 if (stmt->v.Exec.globals != NULL)
- if (!optimize_expr(&stmt->v.Exec.globals, ste, arena))
+ if (!optimize_expr(&stmt->v.Exec.globals, arena))
 return 0;
 if (stmt->v.Exec.locals != NULL)
- if (!optimize_expr(&stmt->v.Exec.locals, ste, arena))
+ if (!optimize_expr(&stmt->v.Exec.locals, arena))
 return 0;
 return 1;
 }
 
 static int
-optimize_stmt(stmt_ty* stmt_ptr, PySTEntryObject* ste, PyArena* arena)
+optimize_stmt(stmt_ty* stmt_ptr, PyArena* arena)
 {
 stmt_ty stmt = *stmt_ptr;
 
 switch (stmt->kind) {
 case FunctionDef_kind:
 {
- int rc;
- ste = PySymtable_Lookup(ste->ste_table, *stmt_ptr);
- if (ste == NULL)
- return 0;
- rc = optimize_function_def(stmt_ptr, ste, arena);
- Py_DECREF(ste);
- return rc;
+ return optimize_function_def(stmt_ptr, arena);
 }
 case ClassDef_kind:
 {
- int rc;
- ste = PySymtable_Lookup(ste->ste_table, *stmt_ptr);
- if (ste == NULL)
- return 0;
- rc = optimize_class_def(stmt_ptr, ste, arena);
- Py_DECREF(ste);
- return rc;
+ return optimize_class_def(stmt_ptr, arena);
 }
 case Return_kind:
 {
- return optimize_return(stmt_ptr, ste, arena);
+ return optimize_return(stmt_ptr, arena);
 }
 case Delete_kind:
 {
- return optimize_delete(stmt_ptr, ste, arena);
+ return optimize_delete(stmt_ptr, arena);
 }
 case Assign_kind:
 {
- return optimize_assign(stmt_ptr, ste, arena);
+ return optimize_assign(stmt_ptr, arena);
 }
 case AugAssign_kind:
 {
- return optimize_aug_assign(stmt_ptr, ste, arena);
+ return optimize_aug_assign(stmt_ptr, arena);
 }
 case Print_kind:
 {
- return optimize_print(stmt_ptr, ste, arena);
+ return optimize_print(stmt_ptr, arena);
 }
 case For_kind:
 {
- return optimize_for(stmt_ptr, ste, arena);
+ return optimize_for(stmt_ptr, arena);
 }
 case While_kind:
 {
- return optimize_while(stmt_ptr, ste, arena);
+ return optimize_while(stmt_ptr, arena);
 }
 case If_kind:
 {
- return optimize_if(stmt_ptr, ste, arena);
+ return optimize_if(stmt_ptr, arena);
 }
 case With_kind:
 {
- return optimize_with(stmt_ptr, ste, arena);
+ return optimize_with(stmt_ptr, arena);
 }
 case Raise_kind:
 {
- return optimize_raise(stmt_ptr, ste, arena);
+ return optimize_raise(stmt_ptr, arena);
 }
 case TryExcept_kind:
 {
- return optimize_try_except(stmt_ptr, ste, arena);
+ return optimize_try_except(stmt_ptr, arena);
 }
 case TryFinally_kind:
 {
- return optimize_try_finally(stmt_ptr, ste, arena);
+ return optimize_try_finally(stmt_ptr, arena);
 }
 case Assert_kind:
 {
- return optimize_assert(stmt_ptr, ste, arena);
+ return optimize_assert(stmt_ptr, arena);
 }
 case Exec_kind:
 {
- return optimize_exec(stmt_ptr, ste, arena);
+ return optimize_exec(stmt_ptr, arena);
 }
 case Expr_kind:
 {
- return optimize_expr(&stmt->v.Expr.value, ste, arena);
+ return optimize_expr(&stmt->v.Expr.value, arena);
 }
 case Import_kind:
 case ImportFrom_kind:
@@ -1242,14 +1211,8 @@
 * Optimize an AST.
 */
 int
-PyAST_Optimize(mod_ty* mod_ptr, struct symtable* st, PyArena* arena)
+PyAST_Optimize(mod_ty* mod_ptr, PyArena* arena)
 {
- int rc;
- PySTEntryObject* ste = PySymtable_Lookup(st, *mod_ptr);
- if (ste == NULL)
- return 0;
- rc = optimize_mod(mod_ptr, ste, arena);
- Py_DECREF(ste);
- return rc;
+ return optimize_mod(mod_ptr, arena);
 }
 
Modified: python/branches/tlee-ast-optimize/Python/pythonrun.c
==============================================================================
--- python/branches/tlee-ast-optimize/Python/pythonrun.c	(original)
+++ python/branches/tlee-ast-optimize/Python/pythonrun.c	Sun Jun 1 18:29:02 2008
@@ -1431,20 +1431,9 @@
 		}
 		mod = PyAST_FromNode(n, flags, filename, arena);
 		PyNode_Free(n);
- if (mod != NULL && flags && !(flags->cf_flags & PyCF_NO_OPTIMIZE)) {
- PyFutureFeatures* future;
- struct symtable* st;
-
- if (!PyAST_BuildSymbolInfo(mod, &future, &st, filename, flags)) {
- if (!PyAST_Optimize(&mod, st, arena)) {
- PyObject_Free(future);
- PySymtable_Free(st);
- return NULL;
- }
- PyObject_Free(future);
- PySymtable_Free(st);
- }
- }
+ if (mod != NULL && flags && !(flags->cf_flags & PyCF_NO_OPTIMIZE))
+ if (!PyAST_Optimize(&mod, arena))
+ return NULL;
 		return mod;
 	}
 	else {
@@ -1470,20 +1459,9 @@
 		}
 		mod = PyAST_FromNode(n, flags, filename, arena);
 		PyNode_Free(n);
- if (mod != NULL && flags && !(flags->cf_flags & PyCF_NO_OPTIMIZE)) {
- PyFutureFeatures* future;
- struct symtable* st;
-
- if (!PyAST_BuildSymbolInfo(mod, &future, &st, filename, flags)) {
- if (!PyAST_Optimize(&mod, st, arena)) {
- PySymtable_Free(st);
- PyObject_Free(future);
- return NULL;
- }
- PySymtable_Free(st);
- PyObject_Free(future);
- }
- }
+ if (mod != NULL && flags && !(flags->cf_flags & PyCF_NO_OPTIMIZE))
+ if (!PyAST_Optimize(&mod, arena))
+ return NULL;
 		return mod;
 	}
 	else {
