diff -r -u5 -P //c/jython/org/python/compiler/CodeCompiler.java //c/jy-exp/org/python/compiler/CodeCompiler.java
--- //c/jython/org/python/compiler/CodeCompiler.java	Mon Feb 19 14:44:24 2001
+++ //c/jy-exp/org/python/compiler/CodeCompiler.java	Thu Mar  8 04:31:50 2001
@@ -1,10 +1,13 @@
 // Copyright © Corporation for National Research Initiatives
 
 package org.python.compiler;
 
 import org.python.parser.*;
+import org.python.core.Py;
+import org.python.core.PyObject;
+import org.python.core.PyException;
 import java.io.IOException;
 import java.util.Stack;
 import java.util.Hashtable;
 import java.util.Vector;
 
@@ -28,12 +31,15 @@
 
     int mode;
     int temporary;
 
     public boolean fast_locals, print_results;
-    public Hashtable locals;
-    public Hashtable globals;
+    
+    public Future futures;
+    public Hashtable tbl;
+    public ScopeInfo my_scope;
+    
     boolean optimizeGlobals = true;
     public Vector names;
     public String className;
 
     public Stack continueLabels, breakLabels, finallyLabels;
@@ -158,40 +164,53 @@
        if (count == 4)
            return;
    }
 
 
+    public void error(String msg,boolean err,SimpleNode node) throws Exception {
+        if (!err) {
+            try {
+                Py.warning(Py.SyntaxWarning,msg,(module.sfilename!=null)?module.sfilename:"?",
+                           node.beginLine,null,Py.None);
+                return;
+            } catch(PyException e) {
+                if (!Py.matchException(e,Py.SyntaxWarning)) throw e;
+            }
+        }
+        throw new ParseException(msg,node);
+    }
+
     public void parse(SimpleNode node, Code code,
                       boolean fast_locals, String className,
-                      boolean classBody, ArgListCompiler ac)
+                      boolean classBody, ScopeInfo scope)
         throws Exception
     {
         this.fast_locals = fast_locals;
         this.className = className;
         this.code = code;
 
-        //Check out locals if fast_locals is on
-        LocalsCompiler lc = new LocalsCompiler();
-        int n = ac.names.size();
-        for (int i=0; i<n; i++) {
-            lc.addLocal((String)ac.names.elementAt(i));
+        if (scope == null) {
+            futures = new Future();
+            futures.preprocessFutures(node,null);
+            new ScopesCompiler(this).parse(node);
+            scope = node.scope;
         }
-        lc.parse(node);
+        
+        my_scope = scope;
+        names = scope.names;
 
-        names = lc.names;
-        locals = lc.locals;
-        globals = lc.globals;
-        optimizeGlobals = lc.optimizeGlobals;
+        tbl = scope.tbl;
+        optimizeGlobals = !scope.exec&&!scope.from_import_star;
 
         mode = GET;
         Object exit = node.visit(this);
         //System.out.println("exit: "+exit+", "+(exit==null));
 
         if (classBody) {
             loadFrame();
             code.invokevirtual("org/python/core/PyFrame", "getf_locals",
-                               "()Lorg/python/core/PyObject;");
+            "()Lorg/python/core/PyObject;");
             code.areturn();
         } else {
             if (exit == null) {
                 //System.out.println("no exit");
                 getNone();
@@ -292,20 +311,53 @@
         } else {
             code.aconst_null();
         }
     }
 
-    int f_globals, PyFunction_init;
+    int getclosure;
+    
+    public boolean makeClosure(Vector freenames) throws Exception {
+        if (freenames == null) return false;
+        int n = freenames.size();
+        if (n == 0) return false;
+
+        if (mrefs.getclosure == 0) {
+            mrefs.getclosure = code.pool.Methodref(
+            "org/python/core/PyFrame", "getclosure",
+            "(I)Lorg/python/core/PyObject;");
+        }
+        
+        int tmp = code.getLocal();
+        code.iconst(n);
+        code.anewarray(code.pool.Class("org/python/core/PyObject"));
+        code.astore(tmp);
+
+        for(int i=0; i<n; i++) {
+            code.aload(tmp);
+            code.iconst(i);
+            code.aload(1); // get frame
+            code.iconst(((SymInfo)tbl.get(freenames.elementAt(i))).env_index);
+            code.invokevirtual(getclosure);
+            code.aastore();
+        }
+        
+        code.aload(tmp);
+        code.freeLocal(tmp);
+        
+        return true;
+    }
+    
+    
+    
+    int f_globals, PyFunction_init, PyFunction_closure_init;
 
     public Object funcdef(SimpleNode node) throws Exception {
         String name = getName(node.getChild(0));
-        ArgListCompiler ac = new ArgListCompiler();
         SimpleNode suite;
         if (node.getNumChildren() == 3) {
             suite = node.getChild(2);
             //Parse arguments
-            node.getChild(1).visit(ac);
         } else {
             suite = node.getChild(1);
         }
 
         setline(node);
@@ -318,23 +370,37 @@
                                                  "f_globals",
                                                  "Lorg/python/core/PyObject;");
         }
         code.getfield(mrefs.f_globals);
 
-        makeArray(ac.getDefaults());
-
-        module.PyCode(suite, name, ac, true, className, false, false,
-                      node.beginLine).get(code);
-
+        makeArray(node.scope.ac.getDefaults());
+        
+        node.scope.setup_closure(my_scope);
+        node.scope.dump();
+        module.PyCode(suite, name, true, className, false, false,
+                      node.beginLine, node.scope).get(code);
+        Vector freenames = node.scope.freevars;
+        node.scope = null; // release scope info
+        
         getDocString(suite);
 
-        if (mrefs.PyFunction_init == 0) {
-            mrefs.PyFunction_init = code.pool.Methodref(
+        if (!makeClosure(freenames)) {
+            if (mrefs.PyFunction_init == 0) {
+                mrefs.PyFunction_init = code.pool.Methodref(
                 "org/python/core/PyFunction", "<init>",
                 "(Lorg/python/core/PyObject;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;Lorg/python/core/PyObject;)V");
+            }
+            code.invokespecial(mrefs.PyFunction_init);
+        } else {
+            if (mrefs.PyFunction_closure_init == 0) {
+                mrefs.PyFunction_closure_init = code.pool.Methodref(
+                "org/python/core/PyFunction", "<init>",
+                "(Lorg/python/core/PyObject;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;Lorg/python/core/PyObject;[Lorg/python/core/PyObject;)V");
+            }
+            code.invokespecial(mrefs.PyFunction_closure_init);
+
         }
-        code.invokespecial(mrefs.PyFunction_init);
 
         set(node.getChild(0));
         return null;
     }
 
@@ -625,10 +691,11 @@
 
 
     public int importAll, importFrom;
 
     public Object ImportFrom(SimpleNode node) throws Exception {
+        Future.checkFromFuture(node); // future stmt support
         setline(node);
         String name = (String)node.getChild(0).visit(this);
         code.ldc(name);
         int n = node.getNumChildren();
         if (n > 1) {
@@ -674,15 +741,10 @@
         }
         return name;
     }
 
     public Object global_stmt(SimpleNode node) throws Exception {
-        int n = node.getNumChildren();
-        for (int i=0; i<n; i++) {
-            Object name = node.getChild(i).getInfo();
-            globals.put(name, name);
-        }
         return null;
     }
 
     public int exec;
     public Object exec_stmt(SimpleNode node) throws Exception {
@@ -713,11 +775,11 @@
         code.invokestatic(mrefs.exec);
         return null;
     }
 
     public int assert1, assert2;
-    public Object assert_stmt(SimpleNode node) throws Exception {
+    public Object assert_stmt(SimpleNode node) throws Exception { // ?? pending __debug__ should be treated as temp global
         setline(node);
         Label end_of_assert = code.getLabel();
  
         /* First do an if __debug__: */
         SimpleNode debugName = new SimpleNode(PythonGrammarTreeConstants.JJTNAME);
@@ -1872,13 +1934,13 @@
         return null;
     }
 
     public int PyTuple_init, PyList_init, PyDictionary_init;
     public Object tuple(SimpleNode node) throws Exception {
-        if (mode ==AUGSET)
+        /* if (mode ==AUGSET)
             throw new ParseException(
-                      "augmented assign to tuple not possible", node);
+                      "augmented assign to tuple not possible", node); */
         if (mode == SET) return seqSet(node);
         if (mode == DEL) return seqDel(node);
 
         code.new_(code.pool.Class("org/python/core/PyTuple"));
         code.dup();
@@ -1896,13 +1958,13 @@
         if (mode == SET) return seqSet(node);
         throw new ParseException("in fplist node", node);
     }
 
     public Object list(SimpleNode node) throws Exception {
-        if (mode ==AUGSET)
+        /* if (mode ==AUGSET)
             throw new ParseException(
-                      "augmented assign to list not possible", node);
+                      "augmented assign to list not possible", node); */
 
         if (node.getNumChildren() > 1 && node.getChild(1).id ==
                       PythonGrammarTreeConstants.JJTFOR_STMT)
              return list_comprehension(node);
 
@@ -2001,19 +2063,16 @@
         code.invokevirtual("org/python/core/PyObject", "__repr__",
                            "()Lorg/python/core/PyString;");
         return null;
     }
 
-    public int PyFunction_init1;
+    public int PyFunction_init1,PyFunction_closure_init1;
     public Object lambdef(SimpleNode node) throws Exception {
         String name = "<lambda>";
-        ArgListCompiler ac = new ArgListCompiler();
         SimpleNode suite;
         if (node.getNumChildren() == 2) {
             suite = node.getChild(1);
-            //Parse arguments
-            node.getChild(0).visit(ac);
         } else {
             suite = node.getChild(0);
         }
 
         //Add a return node onto the outside of suite;
@@ -2031,21 +2090,35 @@
                                                  "f_globals",
                                                  "Lorg/python/core/PyObject;");
         }
         code.getfield(mrefs.f_globals);
 
-        makeArray(ac.getDefaults());
-
-        module.PyCode(retSuite, name, ac, true, className,
-                      false, false, node.beginLine).get(code);
-
-        if (mrefs.PyFunction_init1 == 0) {
-            mrefs.PyFunction_init1 = code.pool.Methodref(
+        makeArray(node.scope.ac.getDefaults());
+        
+        node.scope.setup_closure(my_scope); 
+        node.scope.dump();
+        module.PyCode(retSuite, name, true, className,
+                      false, false, node.beginLine, node.scope).get(code);
+        Vector freenames = node.scope.freevars;
+        node.scope = null; // release scope info
+
+        if (!makeClosure(freenames)) {
+            if (mrefs.PyFunction_init1 == 0) {
+                mrefs.PyFunction_init1 = code.pool.Methodref(
                 "org/python/core/PyFunction", "<init>",
                 "(Lorg/python/core/PyObject;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;)V");
+            }
+            code.invokespecial(mrefs.PyFunction_init1);
+        } else {
+            if (mrefs.PyFunction_closure_init1 == 0) {
+                mrefs.PyFunction_closure_init1 = code.pool.Methodref(
+                "org/python/core/PyFunction", "<init>",
+                "(Lorg/python/core/PyObject;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;[Lorg/python/core/PyObject;)V");
+            }
+            code.invokespecial(mrefs.PyFunction_closure_init1);
         }
-        code.invokespecial(mrefs.PyFunction_init1);
+        
         return null;
     }
 
 
     public int Ellipsis;
@@ -2088,11 +2161,11 @@
         }
         code.invokespecial(mrefs.PySlice_init);
         return null;
     }
 
-    public int makeClass;
+    public int makeClass,makeClass_closure;
     public Object classdef(SimpleNode node) throws Exception {
         setline(node);
 
         //Get class name
         String name = getName(node.getChild(0));
@@ -2104,26 +2177,38 @@
         SimpleNode[] bases = new SimpleNode[n-2];
         for (int i=0; i<n-2; i++)
             bases[i] = node.getChild(i+1);
         makeArray(bases);
 
+        node.scope.setup_closure(my_scope);
+        node.scope.dump();
         //Make code object out of suite
-        module.PyCode(node.getChild(n-1), name,
-                      new ArgListCompiler(), false, name, true, false,
-                      node.beginLine).get(code);
+        module.PyCode(node.getChild(n-1), name, false, name, true, false,
+                      node.beginLine, node.scope).get(code);
+        Vector freenames = node.scope.freevars;
+        node.scope = null; // release scope info
 
         //Get doc string (if there)
         getDocString(node.getChild(n-1));
 
         //Make class out of name, bases, and code
-        if (mrefs.makeClass == 0) {
-            mrefs.makeClass = code.pool.Methodref(
+        if (!makeClosure(freenames)) {
+            if (mrefs.makeClass == 0) {
+                mrefs.makeClass = code.pool.Methodref(
                 "org/python/core/Py", "makeClass",
                 "(Ljava/lang/String;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;Lorg/python/core/PyObject;)Lorg/python/core/PyObject;");
+            }
+            code.invokestatic(mrefs.makeClass);
+        } else {
+            if (mrefs.makeClass_closure == 0) {
+                mrefs.makeClass_closure = code.pool.Methodref(
+                "org/python/core/Py", "makeClass",
+                "(Ljava/lang/String;[Lorg/python/core/PyObject;Lorg/python/core/PyCode;Lorg/python/core/PyObject;[Lorg/python/core/PyObject;)Lorg/python/core/PyObject;");
+            }
+            code.invokestatic(mrefs.makeClass_closure);            
         }
-        code.invokestatic(mrefs.makeClass);
-
+        
         //Assign this new class to the given name
         set(node.getChild(0));
         return null;
     }
 
@@ -2159,10 +2244,11 @@
     }
 
     int getglobal, getlocal1, getlocal2;
     int setglobal, setlocal1, setlocal2;
     int delglobal, dellocal1, dellocal2;
+    int getderef,setderef;
 
     public Object Name(SimpleNode node) throws Exception {
         String name;
         if (fast_locals)
             name = (String)node.getInfo();
@@ -2172,33 +2258,56 @@
         if (mode == AUGGET) 
             mode = GET;
         else if (mode == AUGSET) 
             mode = SET;
 
+        SymInfo syminf = (SymInfo)tbl.get(name);
+        
         switch (mode) {
         case GET:
             loadFrame();
-            if (fast_locals) {
-                Integer i = (Integer)locals.get(name);
-                if (i == null && optimizeGlobals) {
-                    code.ldc(name);
-                    if (mrefs.getglobal == 0) {
-                        mrefs.getglobal = code.pool.Methodref(
+            if (syminf != null) {
+                if (fast_locals) {
+                    if ((syminf.flags&ScopeInfo.GLOBAL) !=0 && optimizeGlobals) {
+                        code.ldc(name);
+                        if (mrefs.getglobal == 0) {
+                            mrefs.getglobal = code.pool.Methodref(
                             "org/python/core/PyFrame", "getglobal",
                             "(Ljava/lang/String;)Lorg/python/core/PyObject;");
+                        }
+                        code.invokevirtual(mrefs.getglobal);
+                        return null;
                     }
-                    code.invokevirtual(mrefs.getglobal);
-                    return null;
-                }
-                if (i != null) {
-                    code.iconst(i.intValue());
-                    if (mrefs.getlocal2 == 0) {
-                        mrefs.getlocal2 = code.pool.Methodref(
+                    if ((syminf.flags&ScopeInfo.GLOBAL)==0 && (syminf.flags&ScopeInfo.CELL)!=0) {
+                        code.iconst(syminf.env_index);
+                        if (mrefs.getderef == 0) {
+                            mrefs.getderef = code.pool.Methodref(
+                            "org/python/core/PyFrame", "getderef",
+                            "(I)Lorg/python/core/PyObject;");
+                        }
+                        code.invokevirtual(mrefs.getderef);
+                        return null;
+                    }
+                    if ((syminf.flags&ScopeInfo.GLOBAL)==0 && (syminf.flags&ScopeInfo.BOUND)!=0) {
+                        code.iconst(syminf.locals_index);
+                        if (mrefs.getlocal2 == 0) {
+                            mrefs.getlocal2 = code.pool.Methodref(
                             "org/python/core/PyFrame", "getlocal",
                             "(I)Lorg/python/core/PyObject;");
+                        }
+                        code.invokevirtual(mrefs.getlocal2);
+                        return null;
                     }
-                    code.invokevirtual(mrefs.getlocal2);
+                }
+                if (my_scope.nested_scopes && (syminf.flags&ScopeInfo.FREE) != 0) {
+                    code.iconst(syminf.env_index);
+                    if (mrefs.getderef == 0) {
+                        mrefs.getderef = code.pool.Methodref(
+                        "org/python/core/PyFrame", "getderef",
+                        "(I)Lorg/python/core/PyObject;");
+                    }
+                    code.invokevirtual(mrefs.getderef);
                     return null;
                 }
             }
             code.ldc(name);
             if (mrefs.getlocal1 == 0) {
@@ -2209,11 +2318,11 @@
             code.invokevirtual(mrefs.getlocal1);
             return null;
 
         case SET:
             loadFrame();
-            if (globals.get(name) != null) {
+            if (syminf != null && (syminf.flags&ScopeInfo.GLOBAL) != 0) {
                 code.ldc(name);
                 code.aload(temporary);
                 if (mrefs.setglobal == 0) {
                     mrefs.setglobal = code.pool.Methodref(
                         "org/python/core/PyFrame", "setglobal",
@@ -2229,28 +2338,38 @@
                             "org/python/core/PyFrame", "setlocal",
                             "(Ljava/lang/String;Lorg/python/core/PyObject;)V");
                     }
                     code.invokevirtual(mrefs.setlocal1);
                 } else {
-                    Integer i = (Integer)locals.get(name);
-                    if (i == null) {
+                    if (syminf == null) {
                         System.err.println("internal compiler error: "+node);
                     }
-                    code.iconst(i.intValue());
-                    code.aload(temporary);
-                    if (mrefs.setlocal2 == 0) {
-                        mrefs.setlocal2 = code.pool.Methodref(
+                    if ((syminf.flags&ScopeInfo.CELL) != 0) {
+                        code.iconst(syminf.env_index);
+                        code.aload(temporary);
+                        if (mrefs.setderef == 0) {
+                            mrefs.setderef = code.pool.Methodref(
+                            "org/python/core/PyFrame", "setderef",
+                            "(ILorg/python/core/PyObject;)V");
+                        }
+                        code.invokevirtual(mrefs.setderef);
+                    } else {
+                        code.iconst(syminf.locals_index);
+                        code.aload(temporary);
+                        if (mrefs.setlocal2 == 0) {
+                            mrefs.setlocal2 = code.pool.Methodref(
                             "org/python/core/PyFrame", "setlocal",
                             "(ILorg/python/core/PyObject;)V");
+                        }
+                        code.invokevirtual(mrefs.setlocal2);
                     }
-                    code.invokevirtual(mrefs.setlocal2);
                 }
             }
             return null;
-        case DEL:
+        case DEL: {
             loadFrame();
-            if (globals.get(name) != null) {
+            if (syminf != null && (syminf.flags&ScopeInfo.GLOBAL) != 0) {
                 code.ldc(name);
                 if (mrefs.delglobal == 0) {
                     mrefs.delglobal = code.pool.Methodref(
                         "org/python/core/PyFrame", "delglobal",
                         "(Ljava/lang/String;)V");
@@ -2264,21 +2383,26 @@
                             "org/python/core/PyFrame", "dellocal",
                             "(Ljava/lang/String;)V");
                     }
                     code.invokevirtual(mrefs.dellocal1);
                 } else {
-                    Integer i = (Integer)locals.get(name);
-                    code.iconst(i.intValue());
+                    if (syminf == null) {
+                        System.err.println("internal compiler error: "+node);
+                    }
+                    if ((syminf.flags&ScopeInfo.CELL) != 0) {
+                        error("can not delete variable '"+name+"' referenced in nested scope",true,node);
+                    }
+                    code.iconst(syminf.locals_index);
                     if (mrefs.dellocal2 == 0) {
                         mrefs.dellocal2 = code.pool.Methodref(
                             "org/python/core/PyFrame", "dellocal",
                             "(I)V");
                     }
                     code.invokevirtual(mrefs.dellocal2);
                 }
             }
-            return null;
+            return null; }
         }
         return null;
     }
 
     public Object String(SimpleNode node) throws Exception {
diff -r -u5 -P //c/jython/org/python/compiler/CompilerFlags.java //c/jy-exp/org/python/compiler/CompilerFlags.java
--- //c/jython/org/python/compiler/CompilerFlags.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/CompilerFlags.java	Thu Mar  8 04:07:12 2001
@@ -0,0 +1,8 @@
+
+package org.python.compiler;
+
+public class CompilerFlags extends Object {
+
+    public boolean nested_scopes;
+
+}
diff -r -u5 -P //c/jython/org/python/compiler/Future.java //c/jy-exp/org/python/compiler/Future.java
--- //c/jython/org/python/compiler/Future.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/Future.java	Thu Mar  8 04:09:56 2001
@@ -0,0 +1,83 @@
+// (C) Copyright 2001 Samuele Pedroni
+
+package org.python.compiler;
+
+import org.python.parser.*;
+
+public class Future extends Object {
+
+    private boolean nested_scopes;
+
+    private static final String FUTURE = "__future__";
+        
+    private boolean check(SimpleNode cand) throws Exception {
+        SimpleNode dotted_name = cand.getChild(0);
+        if (dotted_name.getNumChildren() != 1 || 
+            !((String)dotted_name.getChild(0).getInfo()).equals(FUTURE)) return false;
+        int n = cand.getNumChildren();
+        if (n == 1) {
+            throw new ParseException("future statement does not support import *",cand);           
+        }
+        for (int i = 1; i < n; i++) {
+            SimpleNode imp = cand.getChild(i);
+            String feature;
+            switch(imp.id) {
+            default:
+            case PythonGrammarTreeConstants.JJTNAME:
+                feature = (String)imp.getInfo();
+                break;
+            case PythonGrammarTreeConstants.JJTIMPORT_AS_NAME:
+                feature = (String)imp.getChild(0).getInfo();
+                break;
+            }            
+            // *known* features
+            if (feature.equals("nested_scopes")) {
+                nested_scopes = true;
+                continue;
+            }
+            throw new ParseException("future feature "+feature+" is not defined");
+        }        
+        return true;
+    }
+    
+    public void preprocessFutures(SimpleNode node,CompilerFlags cflags) throws Exception {
+        if (cflags != null) {
+            nested_scopes = cflags.nested_scopes;
+        }
+        if ( node.id != PythonGrammarTreeConstants.JJTFILE_INPUT && 
+            node.id != PythonGrammarTreeConstants.JJTSINGLE_INPUT) return;
+        int n = node.getNumChildren();
+        if (n == 0) return;
+        
+        int beg = 0;
+        if (node.id == PythonGrammarTreeConstants.JJTFILE_INPUT &&
+            node.getChild(0).id == PythonGrammarTreeConstants.JJTEXPR_STMT &&
+            node.getChild(0).getChild(0).id == PythonGrammarTreeConstants.JJTSTRING) beg++;
+        
+        for (int i = beg; i < n; i++) {
+            SimpleNode stmt = node.getChild(i);
+            if (stmt.id != PythonGrammarTreeConstants.JJTIMPORTFROM) break;
+            stmt.from_future_checked = true;
+            if (!check(stmt)) break;
+        }
+        
+        if (cflags != null) {
+            cflags.nested_scopes = cflags.nested_scopes ||  nested_scopes;
+        }
+    }
+    
+
+    public static void checkFromFuture(SimpleNode node) throws Exception {
+        if (node.from_future_checked) return;
+        SimpleNode dotted_name = node.getChild(0);
+        if (dotted_name.getNumChildren() == 1 && ((String)dotted_name.getChild(0).getInfo()).equals(FUTURE)) {
+            throw  new ParseException("from __future__ imports must occur at the beginning of the file",node);
+        }
+        node.from_future_checked = true;        
+    }
+    
+    public boolean areNestedScopesOn() {
+        return nested_scopes;
+    }
+
+}
diff -r -u5 -P //c/jython/org/python/compiler/Module.java //c/jy-exp/org/python/compiler/Module.java
--- //c/jython/org/python/compiler/Module.java	Tue Jan 11 20:38:48 2000
+++ //c/jy-exp/org/python/compiler/Module.java	Thu Mar  8 04:13:22 2001
@@ -190,10 +190,15 @@
     public String[] names;
     public int id;
     public int co_firstlineno;
     public boolean arglist, keywordlist;
     String fname;
+    
+    // for nested scopes
+    public String[] cellvars;
+    public String[] freevars;
+    public int xxx_npurecell;
 
     public PyCodeConstant() { ;
     }
 
     public void get(Code c) throws IOException {
@@ -219,15 +224,20 @@
                                         "L"+module.classfile.name+";");
         c.getstatic(mref_self);
         //c.aconst_null();
 
         c.iconst(id);
+        
+        if (cellvars != null) CodeCompiler.makeStrings(c, cellvars, cellvars.length); else c.aconst_null();
+        if (freevars != null) CodeCompiler.makeStrings(c, freevars, freevars.length); else c.aconst_null();
 
+        c.iconst(xxx_npurecell);
+        
         int mref_newCode = c.pool.Methodref(
             "org/python/core/Py",
             "newCode",
-            "(I[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IZZLorg/python/core/PyFunctionTable;I)Lorg/python/core/PyCode;");
+            "(I[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IZZLorg/python/core/PyFunctionTable;I[Ljava/lang/String;[Ljava/lang/String;I)Lorg/python/core/PyCode;");
 
         c.invokestatic(mref_newCode);
         //c.aconst_null();
         c.putstatic(module.classfile.name, name, "Lorg/python/core/PyCode;");
     }
@@ -326,24 +336,37 @@
             if (!Character.isJavaIdentifierPart(chars[i]))
                 return false;
         }
         return true;
     }
-        
+
+    private static final String[] emptyStringAr = new String[0];
+    
+    private String[] toNameAr(Vector names,boolean nullok) {
+        int sz = names.size();
+        if (sz ==0 && nullok) return null;
+        return (String[])names.toArray(emptyStringAr);
+    }
+    
+    
+    private int to_cell;
+    
     public PyCodeConstant PyCode(SimpleNode tree, String name,
-                                 ArgListCompiler ac,
                                  boolean fast_locals, String className,
                                  boolean classBody, boolean printResults, 
-                                 int firstlineno)
+                                 int firstlineno, ScopeInfo scope)
         throws Exception
     {
         PyCodeConstant code = new PyCodeConstant();
-        int i;
-        code.arglist = ac.arglist;
-        code.keywordlist = ac.keywordlist;
-        code.argcount = ac.names.size();
-
+        ArgListCompiler ac = (scope != null)?scope.ac:null;
+        
+        if (ac != null) {
+            code.arglist = ac.arglist;
+            code.keywordlist = ac.keywordlist;
+            code.argcount = ac.names.size();
+        }
+        
         code.co_name = name;
         code.co_firstlineno = firstlineno;
         code.id = codes.size();
 
         //Better names in the future?
@@ -360,22 +383,43 @@
             ClassFile.PUBLIC);
 
         //Do something to add init_code to tree
         CodeCompiler compiler = new CodeCompiler(this, printResults);
 
-        if (ac.init_code.getNumChildren() > 0) {
+        if (ac != null && ac.init_code.getNumChildren() > 0) {
             ac.init_code.jjtAddChild(tree, ac.init_code.getNumChildren());
             tree = ac.init_code;
         }
+        
+        if (scope != null) {
+          int nparamcell = scope.xxx_paramcells.size();
+          if (nparamcell > 0) {
+            if (to_cell == 0) {
+                to_cell = classfile.pool.Methodref("org/python/core/PyFrame","to_cell","(II)V");
+            }
+            Hashtable tbl = scope.tbl;
+            Vector paramcells = scope.xxx_paramcells;
+            for (int i = 0; i < nparamcell; i++) {
+                c.aload(1);
+                SymInfo syminf = (SymInfo)tbl.get(paramcells.elementAt(i));
+                c.iconst(syminf.locals_index);
+                c.iconst(syminf.env_index);
+                c.invokevirtual(to_cell);
+            }
+          }
+        }
 
-        compiler.parse(tree, c, fast_locals, className, classBody, ac);
+        compiler.parse(tree, c, fast_locals, className, classBody, scope);
 
-        code.names = new String[compiler.names.size()];
-        for(i=0; i<compiler.names.size(); i++) {
-            code.names[i] = (String)compiler.names.elementAt(i);
+        code.names = toNameAr(compiler.names,false);
+        
+        if (scope != null) {
+            code.cellvars = toNameAr(scope.cellvars,true);
+            code.freevars = toNameAr(scope.freevars,true);
+            code.xxx_npurecell = scope.xxx_npurecell;
         }
-
+        
         code.module = this;
         code.name = code.fname;
         return code;
     }
 
@@ -501,12 +545,10 @@
         Module module = new Module(name, filename, linenumbers);
         module.setFile = setFile;
         //Add __doc__ if it exists
         //Add __file__ for filename (if it exists?)
 
-        Constant main = module.PyCode(node, "?",
-                                      new ArgListCompiler(),
-                                      false, null, false, printResults, 0);
+        Constant main = module.PyCode(node, "?",false, null, false, printResults, 0,null);
         module.mainCode = main;
         module.write(ostream);
     }
 }
diff -r -u5 -P //c/jython/org/python/compiler/ScopeConstants.java //c/jy-exp/org/python/compiler/ScopeConstants.java
--- //c/jython/org/python/compiler/ScopeConstants.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/ScopeConstants.java	Thu Mar  8 04:06:30 2001
@@ -0,0 +1,16 @@
+package org.python.compiler;
+
+public interface ScopeConstants {
+    
+    public final static int BOUND = 1;
+    public final static int GLOBAL = 2;
+    public final static int PARAM = 4;
+    public final static int FROM_PARAM = 8;
+    public final static int CELL = 16;
+    public final static int FREE = 32;
+    
+    public final static int TOPSCOPE = 0;
+    public final static int FUNCSCOPE = 1;
+    public final static int CLASSSCOPE = 2;
+
+}
diff -r -u5 -P //c/jython/org/python/compiler/ScopeInfo.java //c/jy-exp/org/python/compiler/ScopeInfo.java
--- //c/jython/org/python/compiler/ScopeInfo.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/ScopeInfo.java	Thu Mar  8 04:09:10 2001
@@ -0,0 +1,222 @@
+// (C) Copyright 2001 Samuele Pedroni
+
+package org.python.compiler;
+
+import java.util.*;
+import org.python.parser.SimpleNode;
+
+public class ScopeInfo extends Object implements ScopeConstants {
+
+    public SimpleNode scope_node;
+    public String scope_name;
+    public int level;
+    public int func_level;
+
+    public void dump() { // for debugging
+        if (org.python.core.Options.verbose < org.python.core.Py.DEBUG) return;
+        for(int i=0; i<level; i++) System.err.print(' ');
+        System.err.print(((kind != CLASSSCOPE)?scope_name:"class "+scope_name)+": ");
+        for (Enumeration e = tbl.keys(); e.hasMoreElements(); ) {
+            String name = (String)e.nextElement();
+            SymInfo info = (SymInfo)tbl.get(name);
+            int flags = info.flags;
+            System.err.print(name);
+            if ((flags&BOUND) != 0) System.err.print('=');
+            if ((flags&GLOBAL) != 0) System.err.print('G');
+            if ((flags&PARAM) != 0) System.err.print('P'); else
+            if ((flags&FROM_PARAM) != 0) System.err.print('p');
+            if ((flags&CELL) != 0) System.err.print('!');
+            if ((flags&FREE) != 0) System.err.print(",f");
+            System.err.print(" ");
+        }
+        System.err.println(); 
+    }
+        
+    public ScopeInfo(String name,SimpleNode node,int level,int kind,int func_level,ArgListCompiler ac,boolean nested_scopes) {
+        scope_name = name;
+        scope_node = node;
+        this.level = level;
+        this.kind = kind;
+        this.func_level = func_level;
+        this.ac = ac;
+        this.nested_scopes = nested_scopes;
+    }
+    
+    public int kind;
+    public boolean nested_scopes;
+    
+    public boolean unqual_exec;
+    public boolean exec;
+    public boolean from_import_star;
+    
+    public ArgListCompiler ac;
+    
+    public Hashtable tbl = new Hashtable();
+    public Vector names = new Vector();
+    
+    public int addGlobal(String name) {
+        SymInfo info = (SymInfo)tbl.get(name);
+        if (info == null) {
+            tbl.put(name,new SymInfo(GLOBAL|BOUND));
+            return -1;
+        }
+        int prev = info.flags;
+        info.flags |= GLOBAL|BOUND;
+        return prev;
+    }
+    
+    public int local = 0;
+    
+    public void addParam(String name) {
+        tbl.put(name, new SymInfo(PARAM|BOUND,local++));
+        names.addElement(name);
+    }
+    
+    public void markFromParam() {
+        for (Enumeration e=tbl.elements(); e.hasMoreElements(); ) {
+            SymInfo info = (SymInfo)e.nextElement();
+            info.flags |= FROM_PARAM;
+        }
+    }
+    
+    public void addBound(String name) {
+        SymInfo info = (SymInfo)tbl.get(name);
+        if (info == null) {
+            tbl.put(name, new SymInfo(BOUND));
+            return;
+        }
+        info.flags |= BOUND;
+    }
+        
+    public void addUsed(String name) {
+        if (tbl.get(name) == null) {
+            tbl.put(name, new SymInfo(0));
+            return;
+        }
+    }
+
+    private final static Object PRESENT = new Object();
+    
+    public Hashtable inner_free = new Hashtable();
+        
+    public Vector cellvars = new Vector();
+    
+    public Vector xxx_paramcells = new Vector();
+    
+    public int xxx_npurecell; // ?? xxx
+    
+    public int cell;
+    
+    public void cook(ScopeInfo up,CodeCompiler ctxt) throws Exception {
+        if (up == null) return; // top level => nop
+        
+        boolean nested_scopes = this.nested_scopes;
+        boolean func = kind == FUNCSCOPE;
+        Vector purecells = new Vector();
+        cell = 0;
+        boolean some_inner_free = inner_free.size() > 0;
+        
+        for (Enumeration e = inner_free.keys(); e.hasMoreElements(); ) {
+            String name = (String)e.nextElement();
+            SymInfo info = (SymInfo)tbl.get(name);
+            if (info == null) {
+                tbl.put(name,new SymInfo(FREE));
+                continue;
+            }
+            int flags = info.flags;
+            if (func) {
+                if ((flags&GLOBAL) == 0 && (flags&BOUND) != 0) {
+                    if (nested_scopes) {
+                        info.flags |= CELL;
+                        if ((info.flags&PARAM) != 0) xxx_paramcells.addElement(name);                        
+                        cellvars.addElement(name);
+                        info.env_index = cell++;
+                        if ((flags&PARAM) == 0) purecells.addElement(name);
+                        continue;
+                    }
+                    ctxt.error("local name '"+name+"' in '"+scope_name+"' shadows use as global in nested scopes",false,scope_node);
+                }
+            } else {
+                info.flags |= FREE;
+            }
+        }
+        boolean some_free = false;
+        
+        boolean nested = up.kind != TOPSCOPE;
+        for (Enumeration e = tbl.keys(); e.hasMoreElements(); ) {
+            String name = (String)e.nextElement();
+            SymInfo info = (SymInfo)tbl.get(name);
+            int flags = info.flags;
+            if (nested && (flags&FREE) != 0) up.inner_free.put(name,PRESENT);
+            if ((flags&(GLOBAL|PARAM|CELL)) == 0) {
+                if ((flags&BOUND) != 0) { // ?? only func
+                    // System.err.println("local: "+name);
+                    names.addElement(name);
+                    info.locals_index = local++;
+                    continue;
+                }
+                info.flags |= FREE;
+                some_free = true;
+                if (nested) up.inner_free.put(name,PRESENT);
+            }
+        }
+        if ((xxx_npurecell = purecells.size()) > 0) {
+            int sz = purecells.size();
+            for (int i = 0; i < sz; i++) {
+                names.addElement(purecells.elementAt(i));
+            }
+        }
+        if ((unqual_exec || from_import_star)) {
+            if(some_inner_free) dynastuff_trouble(true, ctxt);
+            else if(func_level > 1 && some_free) dynastuff_trouble(false, ctxt);
+        }
+        
+    }
+
+    private void dynastuff_trouble(boolean inner_free,CodeCompiler ctxt) throws Exception {
+        String illegal;
+        if (unqual_exec && from_import_star)
+         illegal = "function '"+scope_name+"' uses import * and bare exec, which are illegal";
+        else if (unqual_exec)
+         illegal = "unqualified exec is not allowed in function '"+scope_name+"'";
+        else illegal = "import * is not allowed in function '"+scope_name+"'";
+        String why;
+        if (inner_free)
+         why = " because it contains a function with free variables";
+        else
+         why = " because it contains free variables";
+        ctxt.error(illegal + why ,nested_scopes,scope_node);
+    }
+    
+    public Vector freevars = new Vector();
+
+    public void setup_closure(ScopeInfo up) {
+        if (!nested_scopes) return;
+        int free = cell; // env = cell...,free...
+        Hashtable up_tbl = up.tbl;
+        boolean nested = up.kind != TOPSCOPE;
+        for (Enumeration e = tbl.keys(); e.hasMoreElements(); ) {
+            String name = (String)e.nextElement();
+            SymInfo info = (SymInfo)tbl.get(name);
+            int flags = info.flags;
+            if ((flags&FREE) != 0) {
+                SymInfo up_info = (SymInfo)up_tbl.get(name);
+                if (up_info != null) { // ?? differs from CPython -- what is the intended behaviour?
+                    int up_flags = up_info.flags;
+                    if ((up_flags&(CELL|FREE)) != 0) {
+                        info.env_index = free++;
+                        freevars.addElement(name);
+                        continue;
+                    }
+                    if (nested && (up_flags&GLOBAL) != 0) {
+                        info.flags = GLOBAL|BOUND;
+                        continue;
+                    } 
+                }
+                info.flags &= ~FREE;
+            }
+        }
+        
+    }
+        
+}
diff -r -u5 -P //c/jython/org/python/compiler/ScopesCompiler.java //c/jy-exp/org/python/compiler/ScopesCompiler.java
--- //c/jython/org/python/compiler/ScopesCompiler.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/ScopesCompiler.java	Thu Mar  8 04:09:36 2001
@@ -0,0 +1,649 @@
+// (C) Copyright 2001 Samuele Pedroni
+
+package org.python.compiler;
+
+import org.python.parser.*;
+import java.util.*;
+
+public class ScopesCompiler extends Visitor implements ScopeConstants {
+
+    private CodeCompiler code_compiler;
+    
+    private boolean nested_scopes = false;
+    
+    private Stack scopes;
+    private ScopeInfo cur = null;
+
+    private int mode;
+    private static final int GET=0;
+    private static final int SET=1;
+    private static final int DEL=2;
+    private static final int AUGSET=4;
+
+    private int level      = 0;
+    private int func_level = 0;
+
+    public ScopesCompiler(CodeCompiler code_compiler) { // ?? polish
+        this.code_compiler = code_compiler;
+        scopes = new Stack();
+        mode = GET;
+        String nested_scopes_opt = org.python.core.PySystemState.registry.getProperty("python.xfutures.nested_scopes");
+        if (nested_scopes_opt != null && nested_scopes_opt.equals("on")) nested_scopes = true; else
+        nested_scopes = code_compiler.futures.areNestedScopesOn();
+        // System.err.println("nested-scopes: "+nested_scopes);      
+    }
+
+    public Object set(SimpleNode node) throws Exception {
+        return modal(node,SET);
+    }
+
+    public Object del(SimpleNode node) throws Exception {
+        return modal(node,DEL);
+    }
+
+
+    public Object augset(SimpleNode node) throws Exception {
+        return modal(node,AUGSET);
+    }
+
+    public Object modal(SimpleNode node, int newmode)throws Exception {
+        mode = newmode;
+        node.visit(this);
+        mode = GET;
+        return null;
+    }
+
+    public void beginScope(String name,int kind,SimpleNode node,ArgListCompiler ac) {
+        if (cur != null) {
+            scopes.push(cur);
+        }
+        if (kind == FUNCSCOPE) func_level++;
+        node.scope = cur = new ScopeInfo(name,node,level++,kind,func_level,ac,nested_scopes);
+    }
+
+    public void endScope() throws Exception {
+        if (cur.kind == FUNCSCOPE) func_level--;
+        level--;
+        ScopeInfo up = (!scopes.empty())?(ScopeInfo)scopes.pop():null;
+        cur.cook(up,code_compiler);
+        cur.dump(); // dbg
+        cur = up;
+    }
+
+    public void parse(SimpleNode node) throws Exception {
+            node.visit(this);
+    }
+
+    public Object single_input(SimpleNode node) throws Exception {
+        beginScope("<single-top>",TOPSCOPE,node,null);
+        suite(node);
+        endScope();
+        return null;
+    }
+
+    public Object file_input(SimpleNode node) throws Exception {
+        beginScope("<file-top>",TOPSCOPE,node,null);
+        suite(node);
+        endScope();
+        return null;
+    }
+
+    public Object eval_input(SimpleNode node) throws Exception {
+        beginScope("<eval-top>",TOPSCOPE,node,null);
+        return_stmt(node);
+        endScope();
+        return null;
+    }
+
+    private String def(SimpleNode node) {
+        String name = (String)node.getChild(0).getInfo();
+        cur.addBound(name);
+        return name;
+    }
+
+    public Object funcdef(SimpleNode node) throws Exception {
+        String my_name = def(node);
+        ArgListCompiler ac = new ArgListCompiler();
+        SimpleNode suite;
+        if (node.getNumChildren() == 3) {
+            suite = node.getChild(2);
+            //Parse arguments
+            node.getChild(1).visit(ac);
+        } else {
+            suite = node.getChild(1);
+        }
+        SimpleNode[] defaults = ac.getDefaults();
+        int defc = defaults.length;
+        for(int i=0; i<defc; i++) {
+            defaults[i].visit(this);
+        }
+        beginScope(my_name,FUNCSCOPE,node,ac);
+        int n = ac.names.size();
+        for (int i=0; i<n; i++) {
+            cur.addParam((String)ac.names.elementAt(i));
+        }
+        ac.init_code.visit(this);
+        cur.markFromParam();
+        suite.visit(this);
+        endScope();
+        return null;
+    }
+
+    public Object expr_stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        node.getChild(n-1).visit(this);
+        for (int i=0; i<n-1; i++) {
+            set(node.getChild(i));
+        }
+        return null;
+    }
+
+    public Object print_ext(SimpleNode node) throws Exception {
+        node.getChild(0).visit(this);
+        return null;
+    }
+
+    public Object print_stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        if ( n > 0 ) {
+            for (int i=0; i<n-1; i++) {
+                node.getChild(i).visit(this);
+            }
+            if(node.getChild(n-1).id != PythonGrammarTreeConstants.JJTCOMMA) node.getChild(n-1).visit(this);
+        }
+        return null;
+    }
+
+    public Object del_stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for (int i=0; i<n; i++) {
+            del(node.getChild(i));
+        }
+        return null;
+    }
+
+    public Object pass_stmt(SimpleNode n) throws Exception {
+        return null;
+    }
+
+    public Object break_stmt(SimpleNode n) throws Exception {
+        return null;
+    }
+
+    public Object continue_stmt(SimpleNode n) throws Exception {
+        return null;
+    }
+
+    public Object return_stmt(SimpleNode node) throws Exception {
+        if (node.getNumChildren() == 1) node.getChild(0).visit(this);
+        return null;
+    }
+
+    public void stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for (int i=0; i<n; i++) node.getChild(i).visit(this);
+    }
+
+    public Object raise_stmt(SimpleNode node) throws Exception {
+        stmt(node);
+        return null;
+    }
+
+    public Object Import(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for(int i = 0; i < n; i++) {
+            SimpleNode imp = node.getChild(i);
+            switch(imp.id) {
+            case PythonGrammarTreeConstants.JJTDOTTED_NAME:
+                cur.addBound((String)imp.getChild(0).getInfo());
+                break;
+            case PythonGrammarTreeConstants.JJTDOTTED_AS_NAME:
+                cur.addBound((String)imp.getChild(1).getInfo());
+                break;
+            }
+        }
+        return null;
+    }
+
+    public Object ImportFrom(SimpleNode node) throws Exception {
+        Future.checkFromFuture(node); // future stmt support
+        int n = node.getNumChildren();
+        if (n == 1) {
+            cur.from_import_star = true;
+            return null;
+        }
+        for (int i = 1; i < n; i++) {
+            SimpleNode imp = node.getChild(i);
+            switch(imp.id) {
+            case PythonGrammarTreeConstants.JJTNAME:
+                cur.addBound((String)imp.getInfo());
+                break;
+            case PythonGrammarTreeConstants.JJTIMPORT_AS_NAME:
+                cur.addBound((String)imp.getChild(1).getInfo());
+                break;
+            }
+        }
+
+        return null;
+    }
+
+    public Object global_stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for(int i = 0; i < n; i++) {
+            String name = (String)node.getChild(i).getInfo();
+            int prev = cur.addGlobal(name);
+            if (prev >= 0) {
+                if ((prev&FROM_PARAM) != 0) code_compiler.error("name '"+name+"' is local and global",true,node);
+                if ((prev&GLOBAL) != 0) continue;
+                String what;
+                if ((prev&BOUND) != 0) what = "assignement"; else what = "use";
+                code_compiler.error("name '"+name+"' declared global after "+what,false,node);
+            }
+        }
+        return null;
+    }
+
+    public Object exec_stmt(SimpleNode node) throws Exception {
+        cur.exec = true;
+        int n = node.getNumChildren();
+        if (n == 1) cur.unqual_exec = true;
+        for (int i = 0; i < n; i++) node.getChild(i).visit(this);
+        return null;
+    }
+
+    public Object assert_stmt(SimpleNode node) throws Exception {
+        stmt(node);
+        return null;
+    }
+
+    public Object if_stmt(SimpleNode node) throws Exception {
+        stmt(node);
+        return null;
+    }
+
+    public Object while_stmt(SimpleNode node) throws Exception {
+        stmt(node);
+        return null;
+    }
+
+    public Object for_stmt(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);        
+        set(node.getChild(0));
+        node.getChild(1).visit(this);
+        node.getChild(2).visit(this);
+        if (node.getNumChildren()>3) node.getChild(3).visit(this);
+        return null;
+    }
+
+    public Object try_stmt(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for (int i=0; i<n; i++) {
+            if (i%2 == 1 && i != n-1) {
+                switch(node.getChild(i).getNumChildren()) {
+                case 2:
+                    set(node.getChild(i).getChild(1));
+                case 1:
+                    node.getChild(i).getChild(0).visit(this);
+                }
+                continue;
+            }
+            node.getChild(i).visit(this);
+        }
+        return null;
+    }
+
+    public Object suite(SimpleNode node) throws Exception {
+        stmt(node);
+        return null;
+    }
+
+    private static void illassign(SimpleNode node) throws Exception {
+        String target = "operator";
+        if (node.id == PythonGrammarTreeConstants.JJTCALL_OP) {
+            target = "function call";
+        } else if ((node.id == PythonGrammarTreeConstants.JJTFOR_STMT)) {
+            target = "list comprehension";
+        }
+        throw new ParseException("can't assign to "+target,node);
+    }
+
+    public void binaryop(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        node.getChild(0).visit(this);
+        node.getChild(1).visit(this);
+    }
+
+    public void unaryop(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        node.getChild(0).visit(this);
+    }
+
+
+    public Object or_boolean(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object and_boolean(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object not_1op(SimpleNode node) throws Exception {
+        unaryop(node);
+        return null;
+    }
+
+    public Object comparision(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        int n = node.getNumChildren();
+        for (int i=0; i<n; i++) {
+            if (i%2 == 0) node.getChild(i).visit(this);
+        }
+        return null;
+    }
+
+    public Object or_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object xor_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object and_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object lshift_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object rshift_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object add_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object sub_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object mul_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object div_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object mod_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object pos_1op(SimpleNode node) throws Exception {
+        unaryop(node);
+        return null;
+    }
+
+    public Object neg_1op(SimpleNode node) throws Exception {
+        unaryop(node);
+        return null;
+    }
+
+    public Object invert_1op(SimpleNode node) throws Exception {
+        unaryop(node);
+        return null;
+    }
+
+    public Object pow_2op(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object str_1op(SimpleNode node) throws Exception {
+        unaryop(node);
+        return null;
+    }
+
+    public Object strjoin(SimpleNode node) throws Exception {
+        binaryop(node);
+        return null;
+    }
+
+    public Object Call_Op(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        node.getChild(0).visit(this);
+        if (node.getNumChildren()>1) {
+            SimpleNode args=node.getChild(1);
+            int n = args.getNumChildren();
+            for (int i=0; i<n; i++) {
+                SimpleNode arg = args.getChild(i);
+                switch(arg.id) {
+                case PythonGrammarTreeConstants.JJTKEYWORD:
+                    arg.getChild(1).visit(this);
+                    break;
+                case PythonGrammarTreeConstants.JJTEXTRAARGVALUELIST:
+                case PythonGrammarTreeConstants.JJTEXTRAKEYWORDVALUELIST:
+                    arg.getChild(0).visit(this);
+                    break;
+                default:
+                    arg.visit(this);
+                }
+            }
+        }
+        return null;
+    }
+
+    public Object Index_Op(SimpleNode node) throws Exception {
+        int prevmode= mode;
+        mode = GET;
+        node.getChild(0).visit(this);
+        node.getChild(1).visit(this);
+        mode = prevmode;
+        return null;
+    }
+
+    public Object Dot_Op(SimpleNode node) throws Exception {
+        int prevmode = mode;
+        mode = GET;
+        node.getChild(0).visit(this);
+        mode = prevmode;
+        return null;
+    }
+
+    public Object tuple(SimpleNode node) throws Exception {
+        if (mode ==AUGSET) {
+            throw new ParseException(
+            "augmented assign to tuple not possible", node);
+        }
+        int n = node.getNumChildren();
+        if (n > 0) {
+            for (int i=0; i<n-1; i++) node.getChild(i).visit(this);
+            if (node.getChild(n-1).id != PythonGrammarTreeConstants.JJTCOMMA) node.getChild(n-1).visit(this);
+        }
+        return null;
+    }
+
+    public Object fplist(SimpleNode node) throws Exception {
+        return list(node);
+    }
+
+    public Object list(SimpleNode node) throws Exception {
+        if (mode ==AUGSET) {
+            throw new ParseException(
+            "augmented assign to list not possible", node);
+        }
+        int n = node.getNumChildren();
+        if (n > 0) {
+            for (int i=0; i<n-1; i++) node.getChild(i).visit(this);
+            if (node.getChild(n-1).id != PythonGrammarTreeConstants.JJTCOMMA) node.getChild(n-1).visit(this);
+        }
+        return null;
+    }
+
+    public Object list_iter(SimpleNode node) throws Exception {
+        if (node.getNumChildren() == 1) node.getChild(0).visit(this);
+        return null;
+    }
+
+    public Object dictionary(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        stmt(node);
+        return null;
+    }
+
+    public Object lambdef(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        ArgListCompiler ac = new ArgListCompiler();
+        SimpleNode expr;
+        if (node.getNumChildren() == 2) {
+            expr = node.getChild(1);
+            //Parse arguments
+            node.getChild(0).visit(ac);
+        } else {
+            expr = node.getChild(0);
+        }
+        SimpleNode[] defaults = ac.getDefaults();
+        int defc = defaults.length;
+        for(int i=0; i<defc; i++) {
+            defaults[i].visit(this);
+        }
+        beginScope("<lambda>",FUNCSCOPE,node,ac);
+        int n = ac.names.size();
+        for (int i=0; i<n; i++) {
+            cur.addParam((String)ac.names.elementAt(i));
+        }
+        ac.init_code.visit(this);
+        cur.markFromParam();
+        expr.visit(this);
+        endScope();
+        return null;
+    }
+
+    public Object Ellipses(SimpleNode n) throws Exception {
+        return null;
+    }
+
+    public Object Slice(SimpleNode node) throws Exception {
+        int n = node.getNumChildren();
+        for (int i=0; i<n; i++) {
+            SimpleNode snode = node.getChild(i);
+            if (snode.id != PythonGrammarTreeConstants.JJTCOLON) {
+                snode.visit(this);
+            }
+        }
+        return null;
+    }
+
+    public Object classdef(SimpleNode node) throws Exception {
+        String cl_name = def(node);
+        int n = node.getNumChildren();
+        SimpleNode suite = node.getChild(n-1);
+        for (int i=1; i<n-1; i++) node.getChild(i).visit(this);
+        beginScope(cl_name,CLASSSCOPE,node,null);
+        suite.visit(this);
+        endScope();
+        return null;
+    }
+
+    public Object Int(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        return null;
+    }
+
+    public Object Float(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        return null;
+    }
+
+    public Object Complex(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        return null;
+    }
+
+    public Object Name(SimpleNode node) throws Exception {
+        String name = (String)node.getInfo();
+        if ( mode != GET) cur.addBound(name);
+        else cur.addUsed(name);
+        return null;
+    }
+
+    public Object String(SimpleNode node) throws Exception {
+        if (mode != GET) illassign(node);
+        return null;
+    }
+
+    public void aug_assign(SimpleNode node) throws Exception {
+        augset(node.getChild(0));
+        node.getChild(1).visit(this);
+    }
+
+    public Object aug_plus(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_minus(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_multiply(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_divide(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_modulo(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_and(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_or(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_xor(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_lshift(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_rshift(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+    public Object aug_power(SimpleNode node) throws Exception {
+        aug_assign(node);
+        return null;
+    }
+
+}
diff -r -u5 -P //c/jython/org/python/compiler/SymInfo.java //c/jy-exp/org/python/compiler/SymInfo.java
--- //c/jython/org/python/compiler/SymInfo.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/compiler/SymInfo.java	Thu Mar  8 04:07:12 2001
@@ -0,0 +1,19 @@
+ 
+package org.python.compiler;
+
+public class SymInfo extends Object {
+
+    public SymInfo(int flags) {
+        this.flags = flags;
+    }
+    
+    public SymInfo(int flags,int locals_index) {
+        this.flags = flags;
+        this.locals_index = locals_index;
+    }
+    
+    public int flags;
+    public int locals_index;
+    public int env_index;
+  
+}
diff -r -u5 -P //c/jython/org/python/core/Py.java //c/jy-exp/org/python/core/Py.java
--- //c/jython/org/python/core/Py.java	Mon Mar  5 17:04:36 2001
+++ //c/jy-exp/org/python/core/Py.java	Thu Mar  8 04:21:44 2001
@@ -237,25 +237,62 @@
 
     public static PyObject RuntimeWarning;
     public static void RuntimeWarning(String message) {
         warning(RuntimeWarning, message);
     }
-
+    
+    private static PyObject warnings_mod;
+    private static PyObject importWarnings() {
+        if (warnings_mod != null) return warnings_mod;
+        PyObject mod;
+        try {
+            mod = __builtin__.__import__("warnings");
+        } catch(PyException e) {
+            if (matchException(e,ImportError)) {
+                return null;
+            }
+            throw e;
+        }
+        warnings_mod = mod;
+        return mod;
+    }
+    
+    private static String warn_hcategory(PyObject category) {
+        PyObject name = category.__findattr__("__name__");
+        if (name != null) return "["+name+"]";
+        return "[warning]";
+    }
+    
     public static void warning(PyObject category, String message) {
         PyObject func = null;
-        PyObject mod = __builtin__.__import__("warnings");
+        PyObject mod = importWarnings();
         if (mod != null)
             func = mod.__getattr__("warn");
         if (func == null) {
-            System.err.println("warning: " + message);
+            System.err.println(warn_hcategory(category) + ": " + message);
             return;
         } else {
             func.__call__(Py.newString(message), category);
         }
     }
 
+    public static void warning(PyObject category, String message,String filename,int lineno, String module, PyObject registry) {
+        PyObject func = null;
+        PyObject mod = importWarnings();
+        if (mod != null)
+            func = mod.__getattr__("warn_explicit");
+        if (func == null) {
+            System.err.println(filename + ":" + lineno + ":" + warn_hcategory(category) + ": " + message);
+            return;
+        } else {
+            func.__call__(new PyObject[] {Py.newString(message), category, 
+                Py.newString(filename), Py.newInteger(lineno),
+                (module == null)?Py.None:Py.newString(module), registry}, Py.NoKeywords);
+        }
+    }
 
+    
     public static PyObject JavaError;
     public static PyException JavaError(Throwable t) {
 //         System.err.println("t: "+t);
         if (t instanceof PyException) {
             return (PyException)t;
@@ -393,10 +430,38 @@
 
     public static PyInteger newBoolean(boolean t) {
         return t ? Py.One : Py.Zero;
     }
 
+    // nested scopes:  String[] cellvars,String[] freevars,int xxx_npurecell
+
+    public static PyCode newCode(int argcount, String varnames[],
+                                 String filename, String name,
+                                 boolean args, boolean keywords,
+                                 PyFunctionTable funcs, int func_id,
+                                 String[] cellvars,String[] freevars,int xxx_npurecell)
+    {
+        return new PyTableCode(argcount, varnames,
+                               filename, name, 0, args, keywords, funcs,
+                               func_id, cellvars, freevars, xxx_npurecell);
+    }
+
+    public static PyCode newCode(int argcount, String varnames[],
+                                 String filename, String name,
+                                 int firstlineno,
+                                 boolean args, boolean keywords,
+                                 PyFunctionTable funcs, int func_id,
+                                 String[] cellvars,String[] freevars,int xxx_npurecell)
+
+    {
+        return new PyTableCode(argcount, varnames,
+                               filename, name, firstlineno, args, keywords,
+                               funcs, func_id, cellvars, freevars, xxx_npurecell);
+    }
+        
+    // --
+    
     public static PyCode newCode(int argcount, String varnames[],
                                  String filename, String name,
                                  boolean args, boolean keywords,
                                  PyFunctionTable funcs, int func_id)
     {
@@ -420,11 +485,11 @@
         return new JavaCode(newJavaFunc(cls, name));
     }
 
     public static PyObject newJavaFunc(Class cls, String name) {
         try {
-            java.lang.reflect.Method m = cls.getMethod(name, new Class[] {
+            java.lang.reflect.Method m = cls.getMethod(name, new Class[] { 
                        PyObject[].class, String[].class });
             return new JavaFunc(m);
         } catch (NoSuchMethodException e) {
             throw Py.JavaError(e);
         }
@@ -1300,22 +1365,36 @@
     }
 
     public static PyObject makeClass(String name, PyObject[] bases,
                                      PyCode code, PyObject doc)
     {
-        return makeClass(name, bases, code, doc, null);
+        return makeClass(name, bases, code, doc, null, null);
+    }
+    
+    public static PyObject makeClass(String name, PyObject[] bases,
+                                     PyCode code, PyObject doc,PyObject[] closure_cells)
+    {
+        return makeClass(name, bases, code, doc, null, closure_cells);
     }
 
+    
     public static PyObject makeClass(String name, PyObject[] bases,
                                      PyCode code, PyObject doc,
-                                     Class proxyClass)
+                                     Class proxyClass) {
+        return makeClass(name, bases, code, doc, proxyClass, null);                                      
+    }
+
+
+    public static PyObject makeClass(String name, PyObject[] bases,
+                                     PyCode code, PyObject doc,
+                                     Class proxyClass,PyObject[] closure_cells)
     {
         PyFrame frame = getFrame();
         PyObject globals = frame.f_globals;
 
         PyObject dict = code.call(Py.EmptyObjects, Py.NoKeywords,
-                                  globals, Py.EmptyObjects);
+                                  globals, Py.EmptyObjects,new PyTuple(closure_cells));
         if (doc != null)
             dict.__setitem__("__doc__", doc);
 
         for (int i=0; i<bases.length; i++) {
             if (!(bases[i] instanceof PyClass)) {
@@ -1527,54 +1606,54 @@
         this.func = func;
         if (func instanceof PyReflectedFunction)
             this.co_name = ((PyReflectedFunction) func).__name__;
     }
 
-    public PyObject call(PyFrame frame) {
+    public PyObject call(PyFrame frame, PyObject closure) {
         System.out.println("call #1");
         return Py.None;
     }
 
     public PyObject call(PyObject args[], String keywords[],
-                                  PyObject globals, PyObject[] defaults)
+                                  PyObject globals, PyObject[] defaults, PyObject closure)
     {
         return func.__call__(args, keywords);
     }
 
     public PyObject call(PyObject self, PyObject args[],
                                   String keywords[],
-                                  PyObject globals, PyObject[] defaults)
+                                  PyObject globals, PyObject[] defaults, PyObject closure)
     {
         return func.__call__(self, args, keywords);
     }
 
-    public PyObject call(PyObject globals, PyObject[] defaults)
+    public PyObject call(PyObject globals, PyObject[] defaults, PyObject closure)
     {
         return func.__call__();
     }
 
     public PyObject call(PyObject arg1, PyObject globals,
-                                  PyObject[] defaults)
+                                  PyObject[] defaults, PyObject closure)
     {
         return func.__call__(arg1);
     }
 
     public PyObject call(PyObject arg1, PyObject arg2,
-                                  PyObject globals, PyObject[] defaults)
+                                  PyObject globals, PyObject[] defaults, PyObject closure)
     {
         return func.__call__(arg1, arg2);
     }
 
     public PyObject call(PyObject arg1, PyObject arg2, PyObject arg3,
-                                  PyObject globals, PyObject[] defaults)
+                                  PyObject globals, PyObject[] defaults, PyObject closure)
     {
         return func.__call__(arg1, arg2, arg3);
     }
 }
 
 /**
- * A function object wrapper for a java method which comply with the
+ * A function object wrapper for a java method which comply with the 
  * PyArgsKeywordsCall standard.
  */
 class JavaFunc extends PyObject {
      java.lang.reflect.Method method;
 
@@ -1602,6 +1681,6 @@
     }
 
     public boolean _doset(PyObject container) {
         throw Py.TypeError("java function not settable: "+method.getName());
     }
-}
\ No newline at end of file
+}
diff -r -u5 -P //c/jython/org/python/core/PyCell.java //c/jy-exp/org/python/core/PyCell.java
--- //c/jython/org/python/core/PyCell.java	Thu Jan  1 00:00:00 1970
+++ //c/jy-exp/org/python/core/PyCell.java	Thu Mar  8 04:04:58 2001
@@ -0,0 +1,8 @@
+ 
+package org.python.core;
+
+public class PyCell extends PyObject { // ?? pending repr?
+
+  public PyObject ob_ref;
+    
+}
diff -r -u5 -P //c/jython/org/python/core/PyCode.java //c/jy-exp/org/python/core/PyCode.java
--- //c/jython/org/python/core/PyCode.java	Mon Feb 26 16:24:54 2001
+++ //c/jy-exp/org/python/core/PyCode.java	Thu Mar  8 04:22:36 2001
@@ -5,26 +5,29 @@
  * A super class for all python code implementations.
  */
 public abstract class PyCode extends PyObject
 {
     public String co_name;
-
-    abstract public PyObject call(PyFrame frame);
+    
+    abstract public PyObject call(PyFrame frame, PyObject closure);
+    
+    public PyObject call(PyFrame frame) { return call(frame,null); } // commodity
 
     abstract public PyObject call(PyObject args[], String keywords[],
-                                  PyObject globals, PyObject[] defaults);
+                                  PyObject globals, PyObject[] defaults, PyObject closure);
 
     abstract public PyObject call(PyObject self, PyObject args[],
                                   String keywords[],
-                                  PyObject globals, PyObject[] defaults);
+                                  PyObject globals, PyObject[] defaults,PyObject closure);
 
-    abstract public PyObject call(PyObject globals, PyObject[] defaults);
+    abstract public PyObject call(PyObject globals, PyObject[] defaults, PyObject closure);
 
     abstract public PyObject call(PyObject arg1, PyObject globals,
-                                  PyObject[] defaults);
+                                  PyObject[] defaults, PyObject closure);
 
     abstract public PyObject call(PyObject arg1, PyObject arg2,
-                                  PyObject globals, PyObject[] defaults);
+                                  PyObject globals, PyObject[] defaults, PyObject closure);
 
     abstract public PyObject call(PyObject arg1, PyObject arg2, PyObject arg3,
-                                  PyObject globals, PyObject[] defaults);
+                                  PyObject globals, PyObject[] defaults, PyObject closure);
+
 }
diff -r -u5 -P //c/jython/org/python/core/PyFrame.java //c/jy-exp/org/python/core/PyFrame.java
--- //c/jython/org/python/core/PyFrame.java	Mon Feb 26 16:24:56 2001
+++ //c/jy-exp/org/python/core/PyFrame.java	Thu Mar  8 04:27:04 2001
@@ -13,11 +13,14 @@
     public PyObject f_locals;
     public PyObject f_globals;
     public int f_lineno;
     public PyObject f_builtins;
     public PyObject[] f_fastlocals;
-
+    public PyCell[] f_env; // nested scopes: cell + free env
+    public int f_ncells;
+    public int f_nfreevars;
+    
     // an interface to functions suitable for tracing, e.g. via sys.settrace()
     public TraceFunction tracefunc;
 
     public static PyClass __class__;
 
@@ -34,11 +37,17 @@
         f_locals = locals;
         f_globals = globals;
         f_builtins = builtins;
         // This needs work to be efficient with multiple interpreter states
         if (locals == null && code != null && code.co_varnames.length > 0) {
-            f_fastlocals = new PyObject[code.co_varnames.length];
+            f_fastlocals = new PyObject[code.co_varnames.length-code.xxx_npurecell]; // internal: may change
+        }
+        if (code != null) { // reserve space for env
+            int env_sz = 0;
+            if (code.co_freevars != null) env_sz += (f_nfreevars = code.co_freevars.length);
+            if (code.co_cellvars != null) env_sz += (f_ncells = code.co_cellvars.length);
+            if (env_sz > 0) f_env = new PyCell[env_sz];
         }
     }
 
     public PyFrame(PyTableCode code, PyObject globals) {
         this(code, null, globals, null);
@@ -133,18 +142,18 @@
         }
         return getlocal(f_code.co_varnames[index]);
     }
 
     public PyObject getlocal(String index) {
-        //System.err.println("getlocal: "+index);
+        // System.err.println("getlocal: "+index);
         if (f_locals == null)
             getf_locals();
         PyObject ret = f_locals.__finditem__(index);
         if (ret != null)
             return ret;
 
-        throw Py.NameError("local: '"+index+"'");
+        throw Py.UnboundLocalError("local: '"+index+"'");
         //return getglobal(index);
     }
 
     public PyObject getname(String index) {
         if (f_locals == null) getf_locals();
@@ -202,6 +211,30 @@
     }
 
     public void delglobal(String index) {
         f_globals.__delitem__(index);
     }
+    
+    // nested scopes helpers
+    
+    public PyObject getclosure(int index) {
+        return f_env[index];
+    }
+        
+    public PyObject getderef(int index) {
+        PyObject obj=f_env[index].ob_ref;
+        if (obj != null) return obj;
+        String name;
+        if (index >= f_ncells) name = f_code.co_freevars[index-f_ncells];
+        else name = f_code.co_cellvars[index];
+        throw Py.UnboundLocalError("local: '"+name+"'");        
+    }
+    
+    public void setderef(int index,PyObject value) {
+        f_env[index].ob_ref = value;
+    }
+    
+    public void to_cell(int parm_index,int env_index) {
+        f_env[env_index].ob_ref=f_fastlocals[parm_index];       
+    }
+    
 }
diff -r -u5 -P //c/jython/org/python/core/PyFunction.java //c/jy-exp/org/python/core/PyFunction.java
--- //c/jython/org/python/core/PyFunction.java	Mon Mar  5 17:04:38 2001
+++ //c/jy-exp/org/python/core/PyFunction.java	Thu Mar  8 04:23:18 2001
@@ -11,32 +11,49 @@
     public PyObject __doc__;
     public PyObject func_globals;
     public PyObject[] func_defaults;
     public PyCode func_code;
     public PyObject __dict__;
+    public PyObject func_closure; // nested scopes: closure
 
     public PyFunction(PyObject globals, PyObject[] defaults, PyCode code,
-                      PyObject doc)
+                      PyObject doc,PyObject[] closure_cells)
     {
         func_globals = globals;
         __name__ = code.co_name;
         if (doc == null)
             __doc__ = Py.None;
         else
             __doc__ = doc;
         func_defaults = defaults;
         func_code = code;
+        if (closure_cells != null) {
+            func_closure = new PyTuple(closure_cells);
+        } else {
+            func_closure = null;
+        }
     }
 
+    public PyFunction(PyObject globals, PyObject[] defaults, PyCode code,
+                      PyObject doc) {
+        this(globals,defaults,code,doc,null);
+    }
+    
     public PyFunction(PyObject globals, PyObject[] defaults, PyCode code) {
-        this(globals, defaults, code, null);
+        this(globals, defaults, code, null,null);
     }
+    
+    public PyFunction(PyObject globals, PyObject[] defaults, PyCode code, PyObject[] closure_cells) {
+        this(globals, defaults, code, null,closure_cells);
+    }
+
 
     private static final String[] __members__ = {
         "__doc__", "func_doc",
         "__name__", "func_name", "__dict__",
-        "func_globals", "func_defaults", "func_code"
+        "func_globals", "func_defaults", "func_code",
+        "func_closure"
     };
 
     public PyObject __dir__() {
         PyString members[] = new PyString[__members__.length];
         for (int i = 0; i < __members__.length; i++)
@@ -58,10 +75,16 @@
         // TBD: in CPython, func_code, func_defaults, func_doc, __doc__ are
         // writable.  For now, only func_doc, __doc__ are writable in
         // JPython.
         if (name == "func_doc" || name == "__doc__")
             __doc__ = value;
+        else if (name == "func_closure") {
+            if (!(value instanceof PyTuple)) {
+                throw Py.TypeError("func_closure must be set to a tuple");
+            }
+            func_closure = value;
+        }
         // not yet implemented:
         // func_code
         // func_defaults
         else if (name == "func_defaults")
             throwReadonly(name);
@@ -108,10 +131,14 @@
         // these are special, everything else is findable by reflection
         if (name == "func_doc")
             return __doc__;
         if (name == "func_name")
             return new PyString(__name__);
+        if (name == "func_closure") {
+            if (func_closure != null) return func_closure;
+            return Py.None;
+        }
         if (name == "func_defaults") {
             if (func_defaults.length == 0)
                 return Py.None;
             return new PyTuple(func_defaults);
         }
@@ -135,30 +162,30 @@
     public PyObject _doget(PyObject container, PyObject wherefound) {
         return new PyMethod(container, this, wherefound);
     }
 
     public PyObject __call__() {
-        return func_code.call(func_globals, func_defaults);
+        return func_code.call(func_globals, func_defaults, func_closure);
     }
     public PyObject __call__(PyObject arg) {
-        return func_code.call(arg, func_globals, func_defaults);
+        return func_code.call(arg, func_globals, func_defaults, func_closure);
     }
     public PyObject __call__(PyObject arg1, PyObject arg2) {
-        return func_code.call(arg1, arg2, func_globals, func_defaults);
+        return func_code.call(arg1, arg2, func_globals, func_defaults, func_closure);
     }
     public PyObject __call__(PyObject arg1, PyObject arg2, PyObject arg3) {
-        return func_code.call(arg1, arg2, arg3, func_globals, func_defaults);
+        return func_code.call(arg1, arg2, arg3, func_globals, func_defaults, func_closure);
     }
 
     public PyObject __call__(PyObject[] args, String[] keywords) {
-        return func_code.call(args, keywords, func_globals, func_defaults);
+        return func_code.call(args, keywords, func_globals, func_defaults, func_closure);
     }
     public PyObject __call__(PyObject arg1, PyObject[] args,
                              String[] keywords)
     {
         return func_code.call(arg1, args, keywords, func_globals,
-                              func_defaults);
+                              func_defaults,  func_closure);
     }
     public String toString() {
         return "<function "+__name__+" at "+hashCode()+">";
     }
 }
diff -r -u5 -P //c/jython/org/python/core/PyTableCode.java //c/jy-exp/org/python/core/PyTableCode.java
--- //c/jython/org/python/core/PyTableCode.java	Mon Feb 26 16:25:02 2001
+++ //c/jy-exp/org/python/core/PyTableCode.java	Thu Mar  8 04:25:38 2001
@@ -10,26 +10,43 @@
 {
     public int co_argcount;
     int nargs;
     public int co_firstlineno = -1;
     public String co_varnames[];
+    public String co_cellvars[];
+    public int xxx_npurecell; // internal: may change
+    public String co_freevars[];
     public String co_filename;
     public int co_flags;
     public boolean args, keywords;
     PyFunctionTable funcs;
     int func_id;
-
+   
+    
     public PyTableCode(int argcount, String varnames[],
                        String filename, String name,
                        int firstlineno,
                        boolean args, boolean keywords,
                        PyFunctionTable funcs, int func_id)
     {
+        this(argcount,varnames,filename,name,firstlineno,args,keywords,funcs,func_id,null,null,0);
+    }
+    
+    public PyTableCode(int argcount, String varnames[],
+                       String filename, String name,
+                       int firstlineno,
+                       boolean args, boolean keywords,
+                       PyFunctionTable funcs, int func_id,
+                       String[] cellvars,String[] freevars,int xxx_npurecell) // may change
+    {
         co_argcount = nargs = argcount;
         co_varnames = varnames;
         co_filename = filename;
         co_firstlineno = firstlineno;
+        co_cellvars = cellvars;
+        co_freevars = freevars;
+        this.xxx_npurecell = xxx_npurecell;
         this.args = args;
         co_name = name;
         if (args) {
             co_argcount -= 1;
             co_flags |= 0x04;
@@ -44,11 +61,11 @@
     }
 
     private static final String[] __members__ = {
         "co_name", "co_argcount",
         "co_varnames", "co_filename", "co_firstlineno",
-        "co_flags"
+        "co_flags","co_cellvars","co_freevars"
         // not supported: co_nlocals, co_code, co_consts, co_names,
         // co_lnotab, co_stacksize
     };
 
     public PyObject __dir__() {
@@ -72,22 +89,29 @@
 
     public void __delattr__(String name) {
         throwReadonly(name);
     }
 
+    private static PyTuple toPyStringTuple(String[] ar) {
+        if (ar == null) return Py.EmptyTuple;
+        int sz = ar.length;
+        PyString[] pystr = new PyString[sz];
+        for (int i = 0; i < sz; i++) {
+            pystr[i] = new PyString(ar[i]);
+        }
+        return new PyTuple(pystr);
+    }
+    
     public PyObject __findattr__(String name) {
         // have to craft co_varnames specially
-        if (name == "co_varnames") {
-            PyString varnames[] = new PyString[co_varnames.length];
-            for (int i = 0; i < co_varnames.length; i++)
-                varnames[i] = new PyString(co_varnames[i]);
-            return new PyTuple(varnames);
-        }
+        if (name == "co_varnames") return toPyStringTuple(co_varnames);
+        if (name == "co_cellvars") return toPyStringTuple(co_cellvars);
+        if (name == "co_freevars") return toPyStringTuple(co_freevars);
         return super.__findattr__(name);
     }
 
-    public PyObject call(PyFrame frame) {
+    public PyObject call(PyFrame frame, PyObject closure) {
 //         System.err.println("tablecode call: "+co_name);
         ThreadState ts = Py.getThreadState();
         if (ts.systemState == null) {
             ts.systemState = Py.defaultSystemState;
         }
@@ -105,10 +129,24 @@
                 //System.err.println("ts: "+ts);
                 //System.err.println("ss: "+ts.systemState);
                 frame.f_builtins = ts.systemState.builtins;
             }
         }
+        // nested scopes: setup env with closure
+        int env_j = 0;
+        int ncells = frame.f_ncells;
+        int nfreevars = frame.f_nfreevars;
+        PyCell[] env = frame.f_env;
+        PyTuple freevars = (PyTuple)closure;
+        for (int i = 0; i < ncells; i++,env_j++) {
+            env[env_j] = new PyCell();
+        }
+        for (int i=0; i<nfreevars; i++,env_j++) {
+            env[env_j] = (PyCell)freevars.get(i);
+        }
+        
+        
         ts.frame = frame;
 
         // Handle trace function for debugging
         PySystemState ss = ts.systemState;
         if (ss.tracefunc != null) {
@@ -196,68 +234,68 @@
 
         ts.frame = ts.frame.f_back;
         return ret;
     }
 
-    public PyObject call(PyObject globals, PyObject[] defaults) {
+    public PyObject call(PyObject globals, PyObject[] defaults, PyObject closure) {
         if (co_argcount != 0 || args || keywords)
-            return call(Py.EmptyObjects, Py.NoKeywords, globals, defaults);
+            return call(Py.EmptyObjects, Py.NoKeywords, globals, defaults, closure);
         PyFrame frame = new PyFrame(this, globals);
-        return call(frame);
+        return call(frame, closure);
     }
 
-    public PyObject call(PyObject arg1, PyObject globals, PyObject[] defaults)
+    public PyObject call(PyObject arg1, PyObject globals, PyObject[] defaults, PyObject closure)
     {
         if (co_argcount != 1 || args || keywords)
             return call(new PyObject[] {arg1},
-                        Py.NoKeywords, globals, defaults);
+                        Py.NoKeywords, globals, defaults, closure);
         PyFrame frame = new PyFrame(this, globals);
         frame.f_fastlocals[0] = arg1;
-        return call(frame);
+        return call(frame, closure);
     }
 
     public PyObject call(PyObject arg1, PyObject arg2, PyObject globals,
-                         PyObject[] defaults)
+                         PyObject[] defaults, PyObject closure)
     {
         if (co_argcount != 2 || args || keywords)
             return call(new PyObject[] {arg1, arg2},
-                        Py.NoKeywords, globals, defaults);
+                        Py.NoKeywords, globals, defaults, closure);
         PyFrame frame = new PyFrame(this, globals);
         frame.f_fastlocals[0] = arg1;
         frame.f_fastlocals[1] = arg2;
-        return call(frame);
+        return call(frame, closure);
     }
 
     public PyObject call(PyObject arg1, PyObject arg2, PyObject arg3,
-                         PyObject globals, PyObject[] defaults)
+                         PyObject globals, PyObject[] defaults, PyObject closure)
     {
         if (co_argcount != 2 || args || keywords)
             return call(new PyObject[] {arg1, arg2, arg3},
-                        Py.NoKeywords, globals, defaults);
+                        Py.NoKeywords, globals, defaults, closure);
         PyFrame frame = new PyFrame(this, globals);
         frame.f_fastlocals[0] = arg1;
         frame.f_fastlocals[1] = arg2;
         frame.f_fastlocals[2] = arg3;
-        return call(frame);
+        return call(frame, closure);
     }
 
     public PyObject call(PyObject self, PyObject call_args[],
                          String call_keywords[], PyObject globals,
-                         PyObject[] defaults)
+                         PyObject[] defaults, PyObject closure)
     {
         PyObject[] os = new PyObject[call_args.length+1];
         os[0] = (PyObject)self;
         System.arraycopy(call_args, 0, os, 1, call_args.length);
-        return call(os, call_keywords, globals, defaults);
+        return call(os, call_keywords, globals, defaults, closure);
     }
 
     private String prefix() {
         return co_name.toString()+"() ";
     }
 
     public PyObject call(PyObject call_args[], String call_keywords[],
-                         PyObject globals, PyObject[] defaults)
+                         PyObject globals, PyObject[] defaults, PyObject closure)
     {
         //Needs try except finally blocks
         PyFrame my_frame = new PyFrame(this, globals);
 
         PyObject actual_args[], extra_args[] = null;
@@ -345,11 +383,11 @@
             }
             if (extra_keywords != null) {
                 actual_args[nargs-1] = extra_keywords;
             }
         }
-        return call(my_frame);
+        return call(my_frame, closure);
     }
 
     public String toString() {
         return "<code object " + co_name + " at " + hashCode() +
             ", file \"" + co_filename + "\", line " +
diff -r -u5 -P //c/jython/org/python/parser/SimpleNode.java //c/jy-exp/org/python/parser/SimpleNode.java
--- //c/jython/org/python/parser/SimpleNode.java	Tue Dec  5 18:12:36 2000
+++ //c/jy-exp/org/python/parser/SimpleNode.java	Thu Mar  8 02:14:18 2001
@@ -12,10 +12,13 @@
     protected PythonGrammar parser;
     public int endLine, endColumn, beginLine, beginColumn;
     Object info;
     public int aug_tmp1, aug_tmp2, aug_tmp3, aug_tmp4;
 
+    public org.python.compiler.ScopeInfo scope; // for nested scopes
+    public boolean from_future_checked = false; // from __future__ support
+    
     public SimpleNode(int i) {
         id = i;
     }
 
     public SimpleNode(PythonGrammar p, int i) {
@@ -355,6 +358,5 @@
         }
 
     }
 
 }
-