*** JavaAccessibility.java	Tue Feb 20 16:17:27 2001
--- ../org/python/core/JavaAccessibility.java	Fri Feb  2 00:41:10 2001
***************
*** 16,35 ****
      private static JavaAccessibility access = null;
  
      static void initialize() {
! 	// If we can find it, and the registry option
! 	// python.security.respectJavaAccessibility is set, then we set the
! 	// access object to an instance of the subclass Java2Accessibility
!         if (Options.respectJavaAccessibility && Options.matchJavaAccess==false) {
              return;
!             }
! 	try {
              Class c = Class.forName("org.python.core.Java2Accessibility");
              Class.forName("java.lang.reflect.AccessibleObject");
              access = (JavaAccessibility)c.newInstance();
          }
! 	catch (InstantiationException e) {}
! 	catch (IllegalAccessException e) {}
! 	catch (ClassNotFoundException e) {}
      }
  
      static boolean accessIsMutable() {
--- 16,34 ----
      private static JavaAccessibility access = null;
  
      static void initialize() {
!         // If we can find it, and the registry option
!         // python.security.respectJavaAccessibility is set, then we set the
!         // access object to an instance of the subclass Java2Accessibility
!         if (Options.respectJavaAccessibility)
              return;
!         try {
              Class c = Class.forName("org.python.core.Java2Accessibility");
              Class.forName("java.lang.reflect.AccessibleObject");
              access = (JavaAccessibility)c.newInstance();
          }
!         catch (InstantiationException e) {}
!         catch (IllegalAccessException e) {}
!         catch (ClassNotFoundException e) {}
      }
  
      static boolean accessIsMutable() {
***************
*** 39,76 ****
      /**
       * These methods get overridden in the Java2Accessibility subclass
       */
- 
      void setAccess(Field field, boolean flag) throws SecurityException {
      }
  
      void setAccess(Method method, boolean flag) throws SecurityException {
      }
  
!     void setAccess(Constructor constructor, boolean flag) throws SecurityException {
!     }
!     public static boolean matchJavaAccess()  {
!         if(access == null) return false;
!         return Options.matchJavaAccess;
!     }
      public static void setAccessible(Field field, boolean flag)
          throws SecurityException
      {
!  	if (access != null)
!  	    access.setAccess(field, flag);
      }
  
      public static void setAccessible(Method method, boolean flag)
          throws SecurityException
      {
!  	if (access != null)
!  	    access.setAccess(method, flag);
      }
  
      public static void setAccessible(Constructor constructor, boolean flag)
          throws SecurityException
      {
!  	if (access != null)
!  	    access.setAccess(constructor, flag);
      }
- 
  }
--- 38,71 ----
      /**
       * These methods get overridden in the Java2Accessibility subclass
       */
      void setAccess(Field field, boolean flag) throws SecurityException {
      }
  
      void setAccess(Method method, boolean flag) throws SecurityException {
      }
  
!     void setAccess(Constructor constructor, boolean flag)
!         throws SecurityException
!     {}
! 
      public static void setAccessible(Field field, boolean flag)
          throws SecurityException
      {
!         if (access != null)
!             access.setAccess(field, flag);
      }
  
      public static void setAccessible(Method method, boolean flag)
          throws SecurityException
      {
!         if (access != null)
!             access.setAccess(method, flag);
      }
  
      public static void setAccessible(Constructor constructor, boolean flag)
          throws SecurityException
      {
!         if (access != null)
!             access.setAccess(constructor, flag);
      }
  }
*** Options.java	Tue Feb 20 16:03:49 2001
--- ../org/python/core/Options.java	Fri Feb  2 00:41:10 2001
***************
*** 1,4 ****
! // Copyright ¨ Corporation for National Research Initiatives
  package org.python.core;
  
  public class Options
--- 1,4 ----
! // Copyright © Corporation for National Research Initiatives
  package org.python.core;
  
  public class Options
***************
*** 41,47 ****
      // have unintended side-effects.  This option is temporary.
      public static boolean extendedClassLoader = true;
      */
!     public static boolean matchJavaAccess = false;
      // TBD
      public static boolean importSite = true;
  
--- 41,47 ----
      // have unintended side-effects.  This option is temporary.
      public static boolean extendedClassLoader = true;
      */
! 
      // TBD
      public static boolean importSite = true;
  
***************
*** 60,67 ****
      //
      // ####### END OF OPTIONS
      //
! 
! 
      private static boolean getBooleanOption(String name, boolean defaultValue)
      {
          String prop = PySystemState.registry.getProperty("python."+name);
--- 60,66 ----
      //
      // ####### END OF OPTIONS
      //
! 
      private static boolean getBooleanOption(String name, boolean defaultValue)
      {
          String prop = PySystemState.registry.getProperty("python."+name);
***************
*** 108,116 ****
          Options.proxyDebugDirectory =
              getStringOption("options.proxyDebugDirectory",
                               Options.proxyDebugDirectory);
!         Options.matchJavaAccess =
!             getBooleanOption("security.matchJavaAccess",
!                              Options.matchJavaAccess);
          // verbosity is more complicated:
          String prop = PySystemState.registry.getProperty("python.verbose");
          if (prop != null) {
--- 107,113 ----
          Options.proxyDebugDirectory =
              getStringOption("options.proxyDebugDirectory",
                               Options.proxyDebugDirectory);
! 
          // verbosity is more complicated:
          String prop = PySystemState.registry.getProperty("python.verbose");
          if (prop != null) {
*** PyClass.java	Tue Feb 20 16:26:37 2001
--- ../org/python/core/PyClass.java	Thu Feb 15 06:17:54 2001
***************
*** 151,162 ****
          if (result == null && __bases__ != null) {
              int n = __bases__.__len__();
              for (int i=0; i<n; i++) {
!                 PyClass cls;
!                 cls = (PyClass)(__bases__.__getitem__(i));
!                 if(stop_at_java && cls instanceof PyJavaClass) {
!                   continue;
!                 }
! 				resolvedClass=cls;
                  PyObject[] res = resolvedClass.lookupGivingClass(name,
                                                                 stop_at_java);
                  result = res[0];
--- 151,157 ----
          if (result == null && __bases__ != null) {
              int n = __bases__.__len__();
              for (int i=0; i<n; i++) {
!                 resolvedClass = (PyClass)(__bases__.__getitem__(i));
                  PyObject[] res = resolvedClass.lookupGivingClass(name,
                                                                 stop_at_java);
                  result = res[0];
*** PyInstance.java	Tue Feb 20 16:37:56 2001
--- ../org/python/core/PyInstance.java	Thu Feb 15 06:21:58 2001
***************
*** 180,196 ****
  
      public PyObject __jfindattr__(String name) {
          //System.err.println("jfinding: "+name);
!         //return __findattr__(name, true);
!         PyObject result = ifindlocal(name);
!         if (result != null) {
!             return result;
!         }
!         // it wasn't found in the instance, try the class
!         PyObject[] result2 = __class__.lookupGivingClass(name, true);
!         PyObject pyobj=result2[0];
!         if (pyobj != null &&( pyobj instanceof PyFunction || pyobj instanceof PyBuiltinFunctionSet) )
!             return pyobj._doget(this, result2[1]);
!         return ifindfunction(name);
      }
  
      public PyObject __findattr__(String name) {
--- 180,186 ----
  
      public PyObject __jfindattr__(String name) {
          //System.err.println("jfinding: "+name);
!         return __findattr__(name, true);
      }
  
      public PyObject __findattr__(String name) {
*** PyJavaClass.java	Wed Feb 21 14:26:16 2001
--- ../org/python/core/PyJavaClass.java	Sat Feb 17 02:10:19 2001
***************
*** 1,4 ****
! // Copyright ¨ Corporation for National Research Initiatives
  package org.python.core;
  
  import java.lang.reflect.*;
--- 1,4 ----
! // Copyright © Corporation for National Research Initiatives
  package org.python.core;
  
  import java.lang.reflect.*;
***************
*** 108,113 ****
--- 108,115 ----
                  m.invoke(null, new Object[] { __dict__ });
              }
              catch (Exception exc) {
+                 // System.err.println("Got exception: " + exc + " " +
+                 //                    proxyClass);
                  throw Py.JavaError(exc);
              }
          }
***************
*** 118,123 ****
--- 120,126 ----
                  m.initModule(__dict__);
              }
              catch (Exception exc) {
+ //                 System.err.println("Got exception: " + exc);
                  throw Py.JavaError(exc);
              }
          }
***************
*** 143,161 ****
      private synchronized void init__class__(Class c) {
          if (!PyObject.class.isAssignableFrom(c))
              return;
- 
- //         // Handle the special static __class__ fields on PyObject instances
- //         if (name == "__class__" &&  isstatic &&
- //             PyObject.class.isAssignableFrom(field.getDeclaringClass()) &&
- //             field.getType().isAssignableFrom(PyJavaClass.class)) {
- //             try {
- //                 field.set(null, this);
- //                 continue;
- //             } catch (Throwable t) {
- //                 System.err.println("invalid __class__ field on: "+c.getName());
- //             }
- //         }
- 
          try {
              Field field = c.getField("__class__");
              if (Modifier.isStatic(field.getModifiers()) &&
--- 146,151 ----
***************
*** 173,179 ****
          if (__bases__ != null) return;
  
          Class interfaces[] = getAccessibleInterfaces(c);
- 
          int nInterfaces = interfaces.length;
          int nBases = 0;
          int i;
--- 163,168 ----
***************
*** 218,252 ****
          __name__ = c.getName();
      }
  
       /**
        * Return the list of all accessible fields for a class.  This will
        * only the public fields unless Options.respectJavaAccessibility is
        * false, in which case all fields are returned.
        */
-     private static Field[] filterPublic(Field[] in) {
-           java.util.Vector v=filterPublicMembers(in);
-           if(v.size()==in.length) return in;
-           Field[] ret=new Field[v.size()];
-           v.copyInto(ret);
-           return ret;
-     }
      private static Field[] getAccessibleFields(Class c) {
!         Field[] declared=c.getDeclaredFields();
!  	if (!JavaAccessibility.accessIsMutable()) {
              // returns just the public fields
!  	    return filterPublic(declared);
!         }
!         if(JavaAccessibility.matchJavaAccess()) {
!           declared=filterPublic(declared);
!           if(Modifier.isPublic(c.getModifiers())) return declared;
!         }
!         for (int i=0; i < declared.length; i++) {
!             // TBD: this is a permanent change.  Should we provide a way to
!             // restore the original accessibility flag?
!             JavaAccessibility.setAccessible(declared[i], true);
!         }
! 	return declared;
!         /*
          // from here on out we know we must be using at least Java 1.2.
          // Note that an ArrayList would be better here because we don't
          // need access to be synchronized, but that would prevent this file
--- 207,243 ----
          __name__ = c.getName();
      }
  
+     /**
+      * Return the list of all accessible interfaces for a class.  This will
+      * only the public interfaces. Since we can't set accessibility on
+      * interfaces, the Options.respectJavaAccessibility is not honored.
+      */
+     private static Class[] getAccessibleInterfaces(Class c) {
+         // can't modify accessibility of interfaces in Java2
+         // thus get only public interfaces
+         Class[] in = c.getInterfaces();
+         java.util.Vector v=new java.util.Vector();
+         for (int i = 0; i < in.length; i++) {
+             if (!Modifier.isPublic(in[i].getModifiers()))
+                 continue;
+             v.addElement(in[i]);
+         }
+         if (v.size() == in.length)
+             return in;
+         Class[] ret = new Class[v.size()];
+         v.copyInto(ret);
+         return ret;
+     }
+ 
       /**
        * Return the list of all accessible fields for a class.  This will
        * only the public fields unless Options.respectJavaAccessibility is
        * false, in which case all fields are returned.
        */
      private static Field[] getAccessibleFields(Class c) {
!         if (!JavaAccessibility.accessIsMutable())
              // returns just the public fields
!             return c.getFields();
          // from here on out we know we must be using at least Java 1.2.
          // Note that an ArrayList would be better here because we don't
          // need access to be synchronized, but that would prevent this file
***************
*** 271,285 ****
          Field[] ret = new Field[fields.size()];
          fields.copyInto(ret);
          return ret;
-         */
      }
  
      private void setFields(Class c) {
          Field[] fields = getAccessibleFields(c);
          for (int i=0; i<fields.length; i++) {
              Field field = fields[i];
!             //if (field.getDeclaringClass() != c)
!              //   continue;
  
              String name = getName(field.getName());
              boolean isstatic = Modifier.isStatic(field.getModifiers());
--- 262,275 ----
          Field[] ret = new Field[fields.size()];
          fields.copyInto(ret);
          return ret;
      }
  
      private void setFields(Class c) {
          Field[] fields = getAccessibleFields(c);
          for (int i=0; i<fields.length; i++) {
              Field field = fields[i];
!             if (field.getDeclaringClass() != c)
!                 continue;
  
              String name = getName(field.getName());
              boolean isstatic = Modifier.isStatic(field.getModifiers());
***************
*** 350,360 ****
                 signature.  If this alters the signature of the function in
                 some significant way, then return a duplicate and stick it in
                 the __dict__ */
! 
!             if (o1 != o) { // o1 should be null if this is true?
!                 if (func.handles(meth)) {
                      return;
-                 }
                  func = func.copy();
              }
              func.addMethod(meth);
--- 340,348 ----
                 signature.  If this alters the signature of the function in
                 some significant way, then return a duplicate and stick it in
                 the __dict__ */
!             if (o1 != o) {
!                 if (func.handles(meth))
                      return;
                  func = func.copy();
              }
              func.addMethod(meth);
***************
*** 373,436 ****
          }
          __dict__.__setitem__(name, func);
      }
!     private static Class[] filterPublic(Class[] in) {
!         // Class doesn't implement Member interface
!         java.util.Vector v=new java.util.Vector();
!         for(int i=0;i<in.length;i++) {
!           if(!Modifier.isPublic(in[i].getModifiers())) continue;
!           v.addElement(in[i]);
!         }
!         if(v.size()==in.length) return in;
!         Class[] ret = new Class[v.size()];
!         v.copyInto(ret);
!         return ret;
!     }
!     private static Class[] getAccessibleInterfaces(Class c) {
!       // can't modify accessibility of interfaces in Java2
!       // thus get only public interfaces
!       Class[] interfaces=c.getInterfaces();
!         if(!JavaAccessibility.accessIsMutable())
!           return filterPublic(interfaces);
!         if(JavaAccessibility.matchJavaAccess())
!           return filterPublic(interfaces);
!        return interfaces;
! 
!     }
!      private static java.util.Vector filterPublicMembers(Member[] in)  {
!           java.util.Vector v=new java.util.Vector();
!           for (int i=0; i < in.length; i++) {
!                 if(!Modifier.isPublic(in[i].getModifiers())) continue;
!                 v.addElement(in[i]);
!           }
!           return v;
!     }
       /**
        * Return the list of all accessible methods for a class.  This will
        * only the public methods unless Options.respectJavaAccessibility is
        * false, in which case all methods are returned.
        */
-     private static Method[] filterPublic(Method[] in)  {
-           java.util.Vector v=filterPublicMembers(in);
-           if(v.size()==in.length) return in;
-           Method[] ret=new Method[v.size()];
-           v.copyInto(ret);
-           return ret;
-     }
      private static Method[] getAccessibleMethods(Class c) {
!         Method[] declared= c.getDeclaredMethods();
!         if(!JavaAccessibility.accessIsMutable()) {
!             return filterPublic(declared);
!         }
!         if(JavaAccessibility.matchJavaAccess()) {
!           declared=filterPublic(declared);
!           if(Modifier.isPublic(c.getModifiers())) return declared;
!         }
          for (int i=0; i < declared.length; i++) {
              // TBD: this is a permanent change.  Should we provide a way to
              // restore the original accessibility flag?
              JavaAccessibility.setAccessible(declared[i], true);
          }
! 	return declared;
      }
  
      /* Add all methods declared by this class */
--- 361,384 ----
          }
          __dict__.__setitem__(name, func);
      }
! 
! 
       /**
        * Return the list of all accessible methods for a class.  This will
        * only the public methods unless Options.respectJavaAccessibility is
        * false, in which case all methods are returned.
        */
      private static Method[] getAccessibleMethods(Class c) {
!         if (!JavaAccessibility.accessIsMutable())
!             // returns just the public methods
!             return c.getMethods();
!         Method[] declared = c.getDeclaredMethods();
          for (int i=0; i < declared.length; i++) {
              // TBD: this is a permanent change.  Should we provide a way to
              // restore the original accessibility flag?
              JavaAccessibility.setAccessible(declared[i], true);
          }
!         return declared;
      }
  
      /* Add all methods declared by this class */
***************
*** 452,458 ****
          if (propClass == null)
              return;
  
- 
          boolean set = true;
          name = getName(name);
  
--- 400,405 ----
***************
*** 469,479 ****
              if (o instanceof PyBeanProperty) {
                  PyBeanProperty oldProp = (PyBeanProperty)o;
                  if (prop.myType == oldProp.myType) {
- 
                      // If this adds nothing over old property, do nothing
                      if ((prop.getMethod == null || oldProp.getMethod != null)
                          &&
!                        (prop.setMethod == null || oldProp.setMethod != null))
                      {
                          set = false;
                      }
--- 416,425 ----
              if (o instanceof PyBeanProperty) {
                  PyBeanProperty oldProp = (PyBeanProperty)o;
                  if (prop.myType == oldProp.myType) {
                      // If this adds nothing over old property, do nothing
                      if ((prop.getMethod == null || oldProp.getMethod != null)
                          &&
!                         (prop.setMethod == null || oldProp.setMethod != null))
                      {
                          set = false;
                      }
***************
*** 594,607 ****
              }
  
              PyObject o = __dict__.__finditem__(new PyString(pname));
- 
              PyBeanProperty prop;
              if (o == null || !(o instanceof PyBeanProperty) ) {
- 
                  addProperty(pname, myType, getter, setter);
              } else {
                  prop = (PyBeanProperty)o;
- 
                  if (prop.myType != myType) {
                      if (getter != null) {
                          addProperty(pname, myType, getter, setter);
--- 540,550 ----
***************
*** 662,691 ****
        * constructors are returned.  Note that constructors are not
        * inherited like methods or fields.
        */
-     private static Constructor[] filterPublic(Constructor[] in)  {
-           java.util.Vector v=filterPublicMembers(in);
-           if(v.size()==in.length) return in;
-           Constructor[] ret=new Constructor[v.size()];
-           v.copyInto(ret);
-           return ret;
-     }
      private static Constructor[] getAccessibleConstructors(Class c) {
!         Constructor[] declared=c.getDeclaredConstructors();
! 
!  	if (!JavaAccessibility.accessIsMutable())
              // returns just the public fields
!  	    return filterPublic(declared);
          // return all constructors
!         if(JavaAccessibility.matchJavaAccess()) {
!           declared=filterPublic(declared);
!           if(Modifier.isPublic(c.getModifiers())) return declared;
!         }
          for (int i=0; i < declared.length; i++) {
              // TBD: this is a permanent change.  Should we provide a way to
              // restore the original accessibility flag?
              JavaAccessibility.setAccessible(declared[i], true);
          }
! 	return declared;
      }
  
      private void setConstructors(Class c) {
--- 605,624 ----
        * constructors are returned.  Note that constructors are not
        * inherited like methods or fields.
        */
      private static Constructor[] getAccessibleConstructors(Class c) {
!         if (!JavaAccessibility.accessIsMutable())
              // returns just the public fields
!             return c.getConstructors();
          // return all constructors
! 
! 
!         Constructor[] declared = c.getDeclaredConstructors();
          for (int i=0; i < declared.length; i++) {
              // TBD: this is a permanent change.  Should we provide a way to
              // restore the original accessibility flag?
              JavaAccessibility.setAccessible(declared[i], true);
          }
!         return declared;
      }
  
      private void setConstructors(Class c) {
***************
*** 862,868 ****
          PyInstance inst = new PyJavaInstance(this);
          inst.__init__(args, keywords);
  
!         if (proxyClass != null && PyObject.class.isAssignableFrom(proxyClass)) {
              // It would be better if we didn't have to create a PyInstance
              // in the first place.
              ((PyObject)inst.javaProxy).__class__ = this;
--- 795,802 ----
          PyInstance inst = new PyJavaInstance(this);
          inst.__init__(args, keywords);
  
!         if (proxyClass != null &&
!                     PyObject.class.isAssignableFrom(proxyClass)) {
              // It would be better if we didn't have to create a PyInstance
              // in the first place.
              ((PyObject)inst.javaProxy).__class__ = this;
*** PyObject.java	Tue Feb 20 16:52:46 2001
--- ../org/python/core/PyObject.java	Fri Feb  2 17:28:37 2001
***************
*** 465,471 ****
      public PyObject __getitem__(int key) {
          PyObject ret = __finditem__(key);
          if (ret == null)
!             throw Py.IndexError(""+key);
          return ret;
      }
  
--- 465,471 ----
      public PyObject __getitem__(int key) {
          PyObject ret = __finditem__(key);
          if (ret == null)
!             throw Py.KeyError(""+key);
          return ret;
      }
  
***************
*** 515,525 ****
      **/
      public PyObject __getitem__(PyObject key) {
          PyObject ret = __finditem__(key);
!         if (ret == null) {
! 			if(key instanceof PyInteger)
!             	throw Py.IndexError(key.toString());
              throw Py.KeyError(key.toString());
- 		}
          return ret;
      }
  
--- 515,522 ----
      **/
      public PyObject __getitem__(PyObject key) {
          PyObject ret = __finditem__(key);
!         if (ret == null)
              throw Py.KeyError(key.toString());
          return ret;
      }
  
*** PyReflectedFunction.java	Tue Feb 20 16:22:01 2001
--- ../org/python/core/PyReflectedFunction.java	Fri Feb  2 17:28:37 2001
***************
*** 141,147 ****
          Object cself = callData.self;
          // Check to see if we should be using a super__ method instead
          // This is probably a bit inefficient...
!         if (self == null && cself != null && cself instanceof PyProxy && !__name__.startsWith("super__")) {
              PyInstance iself = ((PyProxy)cself)._getPyInstance();
              if (argslist[0].declaringClass != iself.__class__.proxyClass) {
                  PyJavaClass jc =
--- 141,147 ----
          Object cself = callData.self;
          // Check to see if we should be using a super__ method instead
          // This is probably a bit inefficient...
!         if (self == null && cself != null && cself instanceof PyProxy) {
              PyInstance iself = ((PyProxy)cself)._getPyInstance();
              if (argslist[0].declaringClass != iself.__class__.proxyClass) {
                  PyJavaClass jc =
*** JavaMaker.java	Tue Feb 20 16:14:19 2001
--- ../org/python/compiler/JavaMaker.java	Thu Feb 15 06:23:40 2001
***************
*** 124,138 ****
          }
      }
  
-     public void addSuperMethod(String methodName, String superName,
-                                String superclass, Class[] parameters,
-                                Class ret, String sig, int access)
-         throws Exception {
-           if(methodName.startsWith("super__") && superclass.startsWith("org/python/proxies")==false) {
-              super.addSuperMethod(methodName,superName,superclass,parameters,ret,sig,access);
-           }
-   	}
- 
  
      public void addMain() throws Exception {
          Code code = classfile.addMethod("main", "([Ljava/lang/String;)V",
--- 124,129 ----