libjava/classpath/ChangeLog.gcj:

2007-05-31  Matthias Klose  <doko@ubuntu.com>

        * javax/management/NotificationBroadcasterSupport.java
        (getNotificationInfo): Add cast.
        * native/jni/qt-peer/Makefile.am (AM_CXXFLAGS): Add libstdc++ include
        directories.
        * native/jni/qt-peer/Makefile.in: Regenerate.

libjava/ChangeLog:

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        * java/io/natFileWin32.cc (setFilePermissions): New (stub only).
        _access: Handle EXEC query, stub only.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        Merged from classpath:
        * gnu/java/nio/SelectorProviderImpl.java: Whitespace merge.
        * java/lang/System.java(inheritedChannel): New.
        * java/lang/Character.java: Remove stray`;'.
        * java/net/MulticastSocket.java: Merged.
        * java/text/DateFormatSymbols.java(getInstance): New, comment updates.
        * java/text/Collator.java(getInstance): Merged.
        * java/util/Calendar.java: New attributes ALL_STYLES, SHORT, LONG.
        getDisplayName, getDisplayNames: New.
        * java/util/logging/Logger.java: Merged.
        * Regenerate .class and .h files.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        * java/io/File.java: Merge with classpath-0.95, new method
        setFilePermissions, new attribute EXEC.
        * java/io/natFilePosix.cc (setFilePermissions): New.
        _access: Handle EXEC query.
        * classpath/lib/java/io/File.class, java/io/File.h: Regenerate.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        Imported GNU Classpath 0.95.

        * classpath/Makefile.in,
        classpath/native/jni/midi-dssi/Makefile.in,
        classpath/native/jni/classpath/Makefile.in,
        classpath/native/jni/Makefile.in,
        classpath/native/jni/gconf-peer/Makefile.in,
        classpath/native/jni/java-io/Makefile.in,
        classpath/native/jni/native-lib/Makefile.in,
        classpath/native/jni/java-util/Makefile.in,
        classpath/native/jni/midi-alsa/Makefile.in,
        classpath/native/jni/java-lang/Makefile.in,
        classpath/native/jni/java-nio/Makefile.in,
        classpath/native/jni/java-net/Makefile.in,
        classpath/native/jni/xmlj/Makefile.in,
        classpath/native/jni/qt-peer/Makefile.in,
        classpath/native/jni/gtk-peer/Makefile.in,
        classpath/native/Makefile.in, classpath/native/jawt/Makefile.in,
        classpath/native/fdlibm/Makefile.in,
        classpath/native/plugin/Makefile.in,
        classpath/resource/Makefile.in, classpath/scripts/Makefile.in,
        classpath/tools/Makefile.in, classpath/doc/Makefile.in,
        classpath/doc/api/Makefile.in, classpath/lib/Makefile.in,
        classpath/external/Makefile.in, classpath/external/jsr166/Makefile.in,
        classpath/external/sax/Makefile.in,
        classpath/external/w3c_dom/Makefile.in,
        classpath/external/relaxngDatatype/Makefile.in,
        classpath/include/Makefile.in,
        classpath/examples/Makefile.in: Regenerate.
        * classpath/config.guess, classpath/config.sub,
        classpath/ltmain.sh : Update.
        * classpath/configure, classpath/depcomp, classpath/missing,
        classpath/aclocal.m4, classpath/install-sh: Regenerate.

        * gnu/classpath/Configuration.java (CLASSPATH_VERSION): Now 0.95.
        * sources.am: Regenerate.
        * Makefile.in: Regenerate.

        * Update the .class files and generated CNI header files, add new
        .class and generated CNI header files.
        * Remove generated files for removed java source files:
        classpath/gnu/java/net/BASE64.java,
        classpath/gnu/java/security/util/Base64.java,
        classpath/gnu/java/awt/peer/gtk/GThreadMutex.java,
        classpath/gnu/java/awt/peer/gtk/GThreadNativeMethodRunner.java,
        classpath/gnu/java/awt/font/autofit/Scaler.java,
        classpath/gnu/classpath/jdwp/util/Value.java,
        classpath/gnu/javax/net/ssl/Base64.java.
        * Remove empty directories.

        * Makefile.am(nat_source_files): Add natVMOperatingSystemMXBeanImpl.cc.
        * java/lang/Class.java(setAccessible): Merge from classpath.
        * java/util/Locale.java: Remove.
        * gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java,
        gnu/java/lang/management/natVMOperatingSystemMXBeanImpl.cc: New.
        * gcj/javaprims.h: Update class declarations.
        * scripts/classes.pl: Update usage.
        * HACKING: Mention to build all peers.

From-SVN: r125302

libjava/java/io/File.h

@@ -31,6 +31,7 @@ class java::io::File : public ::java::lang::Object
 public:
   virtual jboolean canRead();
   virtual jboolean canWrite();
+  virtual jboolean canExecute();
 private:
   jboolean performCreate();
 public:
@@ -92,6 +93,15 @@ private:
   static ::java::lang::String * nextValue();
 public:
   static ::java::io::File * createTempFile(::java::lang::String *, ::java::lang::String *, ::java::io::File *);
+private:
+  jboolean setFilePermissions(jboolean, jboolean, jint);
+public:
+  virtual jboolean setReadable(jboolean);
+  virtual jboolean setReadable(jboolean, jboolean);
+  virtual jboolean setWritable(jboolean);
+  virtual jboolean setWritable(jboolean, jboolean);
+  virtual jboolean setExecutable(jboolean);
+  virtual jboolean setExecutable(jboolean, jboolean);
 private:
   jboolean performSetReadOnly();
 public:
@@ -114,6 +124,7 @@ public:
 private:
   void checkWrite();
   void checkRead();
+  void checkExec();
 public:
   virtual void deleteOnExit();
 private:
@@ -123,6 +134,7 @@ private:
   static const jint READ = 0;
   static const jint WRITE = 1;
   static const jint EXISTS = 2;
+  static const jint EXEC = 3;
   static const jint DIRECTORY = 0;
   static const jint ISFILE = 1;
   static const jint ISHIDDEN = 2;

libjava/java/io/File.java

@@ -67,6 +67,7 @@ public class File implements Serializable, Comparable
   private final static int READ = 0;
   private final static int WRITE = 1;
   private final static int EXISTS = 2;
+  private final static int EXEC = 3;
 
   // QUERY arguments to stat function.
   private final static int DIRECTORY = 0;
@@ -182,6 +183,27 @@ public class File implements Serializable, Comparable
     return _access (WRITE);
   }
   
+  /**
+   * This method tests whether or not the current thread is allowed to
+   * to execute the file pointed to by this object. This will be true if and
+   * and only if 1) the file exists and 2) the <code>SecurityManager</code>
+   * (if any) allows access to the file via it's <code>checkExec</code>
+   * method 3) the file is executable.
+   *
+   * @return <code>true</code> if execution is allowed, 
+   * <code>false</code> otherwise
+   *
+   * @exception SecurityException If the <code>SecurityManager</code> 
+   * does not allow access to the file
+   */
+  public boolean canExecute()
+  {
+    if (!exists())
+      return false;
+    checkExec();
+    return _access (EXEC);
+  }
+
   private native boolean performCreate() throws IOException;
 
   /**
@@ -1138,6 +1160,159 @@ public class File implements Serializable, Comparable
     throw new IOException ("cannot create temporary file");
   }
 
+  /*
+   * This native method sets file permissions.
+   */
+  private native boolean setFilePermissions(boolean enable, boolean ownerOnly,
+					    int permissions);
+
+  /**
+   * This method sets the owner's read permission for the File represented by
+   * this object.
+   * 
+   * It is the same as calling <code>setReadable(readable, true)</code>.
+   * 
+   * @param <code>readable</code> <code>true</code> to set read permission,
+   * <code>false</code> to unset the read permission.
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setReadable(boolean, boolean)
+   * @since 1.6
+   */
+  public boolean setReadable(boolean readable)
+  {
+    return setReadable(readable, true);
+  }
+  
+  /**
+   * This method sets the read permissions for the File represented by
+   * this object.
+   * 
+   * If <code>ownerOnly</code> is set to <code>true</code> then only the
+   * read permission bit for the owner of the file is changed.
+   * 
+   * If <code>ownerOnly</code> is set to <code>false</code>, the file
+   * permissions are changed so that the file can be read by everyone.
+   * 
+   * On unix like systems this sets the <code>user</code>, <code>group</code>
+   * and <code>other</code> read bits and is equal to call
+   * <code>chmod a+r</code> on the file.
+   * 
+   * @param <code>readable</code> <code>true</code> to set read permission,
+   * <code>false</code> to unset the read permission.
+   * @param <code>ownerOnly</code> <code>true</code> to set read permission
+   * for owner only, <code>false</code> for all.
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setReadable(boolean)
+   * @since 1.6
+   */
+  public boolean setReadable(boolean readable, boolean ownerOnly)
+  {
+    checkWrite();
+    return setFilePermissions(readable, ownerOnly, READ);
+  }
+  
+  /**
+   * This method sets the owner's write permission for the File represented by
+   * this object.
+   * 
+   * It is the same as calling <code>setWritable(readable, true)</code>. 
+   * 
+   * @param <code>writable</code> <code>true</code> to set write permission,
+   * <code>false</code> to unset write permission.
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setWritable(boolean, boolean)
+   * @since 1.6
+   */
+  public boolean setWritable(boolean writable)
+  {
+    return setWritable(writable, true);
+  }
+  
+  /**
+   * This method sets the write permissions for the File represented by
+   * this object.
+   * 
+   * If <code>ownerOnly</code> is set to <code>true</code> then only the
+   * write permission bit for the owner of the file is changed.
+   * 
+   * If <code>ownerOnly</code> is set to <code>false</code>, the file
+   * permissions are changed so that the file can be written by everyone.
+   * 
+   * On unix like systems this set the <code>user</code>, <code>group</code>
+   * and <code>other</code> write bits and is equal to call
+   * <code>chmod a+w</code> on the file.
+   * 
+   * @param <code>writable</code> <code>true</code> to set write permission,
+   * <code>false</code> to unset write permission.
+   * @param <code>ownerOnly</code> <code>true</code> to set write permission
+   * for owner only, <code>false</code> for all. 
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setWritable(boolean)
+   * @since 1.6
+   */
+  public boolean setWritable(boolean writable, boolean ownerOnly)
+  {
+    checkWrite();
+    return setFilePermissions(writable, ownerOnly, WRITE);
+  }
+  
+  /**
+   * This method sets the owner's execute permission for the File represented
+   * by this object.
+   * 
+   * It is the same as calling <code>setExecutable(readable, true)</code>. 
+   * 
+   * @param <code>executable</code> <code>true</code> to set execute permission,
+   * <code>false</code> to unset execute permission.
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setExecutable(boolean, boolean)
+   * @since 1.6
+   */
+  public boolean setExecutable(boolean executable) 
+  {
+    return setExecutable(executable, true);
+  }
+  
+  /**
+   * This method sets the execute permissions for the File represented by
+   * this object.
+   * 
+   * If <code>ownerOnly</code> is set to <code>true</code> then only the
+   * execute permission bit for the owner of the file is changed.
+   * 
+   * If <code>ownerOnly</code> is set to <code>false</code>, the file
+   * permissions are changed so that the file can be executed by everyone.
+   * 
+   * On unix like systems this set the <code>user</code>, <code>group</code>
+   * and <code>other</code> write bits and is equal to call
+   * <code>chmod a+x</code> on the file.
+   * 
+   * @param <code>executable</code> <code>true</code> to set write permission,
+   * <code>false</code> to unset write permission.
+   * @param <code>ownerOnly</code> <code>true</code> to set write permission
+   * for owner only, <code>false</code> for all. 
+   * @return <code>true</code> if the file permissions are changed,
+   * <code>false</code> otherwise.
+   * @exception SecurityException If write access of the file is not permitted.
+   * @see #setExecutable(boolean)
+   * @since 1.6
+   */
+  public boolean setExecutable(boolean executable, boolean ownerOnly)
+  {
+    checkWrite();
+    return setFilePermissions(executable, ownerOnly, EXEC);
+  }
+
   /*
    * This native method sets the permissions to make the file read only.
    */
@@ -1372,6 +1547,15 @@ public class File implements Serializable, Comparable
       s.checkRead(path);
   }
 
+  private void checkExec()
+  {
+    // Check the SecurityManager
+    SecurityManager s = System.getSecurityManager();
+    
+    if (s != null)
+      s.checkExec(path);
+  }
+
   /** 
    * Calling this method requests that the file represented by this object
    * be deleted when the virtual machine exits.  Note that this request cannot

libjava/java/io/ObjectInputStream.h

@@ -16,8 +16,10 @@ class java::io::ObjectInputStream : public ::java::io::InputStream
 public:
   ObjectInputStream(::java::io::InputStream *);
   virtual ::java::lang::Object * readObject();
+  virtual ::java::lang::Object * readUnshared();
 private:
-  ::java::lang::Object * parseContent(jbyte);
+  ::java::lang::Object * readObject(jboolean);
+  ::java::lang::Object * parseContent(jbyte, jboolean);
   void checkTypeConsistency(::java::lang::String *, JArray< ::java::io::ObjectStreamField * > *, JArray< ::java::io::ObjectStreamField * > *);
 public: // actually protected
   virtual ::java::io::ObjectStreamClass * readClassDescriptor();
@@ -60,10 +62,10 @@ public: // actually protected
   ObjectInputStream();
   virtual ::java::lang::Object * readObjectOverride();
 private:
-  jint assignNewHandle(::java::lang::Object *);
-  void rememberHandle(::java::lang::Object *, jint);
+  jint assignNewHandle(::java::lang::Object *, jboolean);
+  void rememberHandle(::java::lang::Object *, jboolean, jint);
   ::java::lang::Object * lookupHandle(jint);
-  ::java::lang::Object * processResolution(::java::io::ObjectStreamClass *, ::java::lang::Object *, jint);
+  ::java::lang::Object * processResolution(::java::io::ObjectStreamClass *, ::java::lang::Object *, jint, jboolean);
   void clearHandles();
   void readNextBlock();
   void readNextBlock(jbyte);
@@ -86,7 +88,7 @@ private:
   jboolean useSubclassMethod;
   jint nextOID;
   jboolean resolveEnabled;
-  ::java::util::Vector * objectLookupTable;
+  ::java::util::Map * handles;
   ::java::lang::Object * currentObject;
   ::java::io::ObjectStreamClass * currentObjectStreamClass;
   ::java::util::TreeSet * currentObjectValidators;

libjava/java/io/ObjectOutputStream.h

@@ -36,6 +36,9 @@ class java::io::ObjectOutputStream : public ::java::io::OutputStream
 public:
   ObjectOutputStream(::java::io::OutputStream *);
   virtual void writeObject(::java::lang::Object *);
+  virtual void writeUnshared(::java::lang::Object *);
+private:
+  void writeObject(::java::lang::Object *, jboolean);
 public: // actually protected
   virtual void writeClassDescriptor(::java::io::ObjectStreamClass *);
 public:

libjava/java/io/natFilePosix.cc

@@ -43,15 +43,18 @@ java::io::File::_access (jint query)
   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
   buf[total] = '\0';
-  JvAssert (query == READ || query == WRITE || query == EXISTS);
+  JvAssert (query == READ || query == WRITE || query == EXISTS
+	    || query == EXEC);
 #ifdef HAVE_ACCESS
   int mode;
   if (query == READ)
     mode = R_OK;
   else if (query == WRITE)
     mode = W_OK;
-  else
+  else if (query == EXISTS)
     mode = F_OK;
+  else
+    mode = X_OK;
   return ::access (buf, mode) == 0;
 #else
   return false;
@@ -343,6 +346,54 @@ java::io::File::performMkdir (void)
 #endif
 }
 
+jboolean
+java::io::File::setFilePermissions (jboolean enable,
+				    jboolean ownerOnly,
+				    jint permissions)
+{
+  char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
+  jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
+  buf[total] = '\0';
+  JvAssert (permissions == READ || permissions == WRITE || permissions == EXEC);
+#if defined (HAVE_STAT) && defined (HAVE_CHMOD)
+  mode_t mode = 0;
+
+  struct stat sb;
+  if (::stat (buf, &sb))
+    return false;
+
+  if (ownerOnly)
+    {
+      if (permissions == READ)
+        mode |= S_IRUSR;
+      else if (permissions == WRITE)
+        mode |= S_IWUSR;
+      else if (permissions == EXEC)
+        mode |= S_IXUSR;
+    }
+  else
+    {
+      if (permissions == READ)
+        mode |= (S_IRUSR | S_IRGRP | S_IROTH);
+      else if (permissions == WRITE)
+        mode |= (S_IWUSR | S_IWGRP | S_IWOTH);
+      else if (permissions == EXEC)
+        mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
+    }
+  
+  if (enable)
+    mode = sb.st_mode | mode;
+  else
+    mode = sb.st_mode & ~mode;
+  
+  if (::chmod(buf, mode) < 0)
+    return false;
+  return true;
+#else
+  return false;
+#endif
+}
+
 jboolean
 java::io::File::performSetReadOnly (void)
 {

libjava/java/io/natFileWin32.cc

@@ -44,13 +44,17 @@ java::io::File::_access (jint query)
   if (!canon)
     return false;
 
-  JvAssert (query == READ || query == WRITE || query == EXISTS);
+  JvAssert (query == READ || query == WRITE || query == EXISTS
+	    || query == EXEC);
 
   // FIXME: Is it possible to differentiate between existing and reading?
   // If the file exists but cannot be read because of the secuirty attributes
   // on an NTFS disk this wont work (it reports it can be read but cant)
   // Could we use something from the security API?
   DWORD attributes = GetFileAttributes (canon);
+  // FIXME: handle EXEC
+  if (query == EXEC)
+    return false;
   if ((query == EXISTS) || (query == READ))
     return (attributes == 0xffffffff) ? false : true;
   else
@@ -211,6 +215,25 @@ java::io::File::performList (java::io::FilenameFilter *filter,
   return ret;
 }
 
+jboolean
+java::io::File::setFilePermissions (jboolean enable,
+				    jboolean ownerOnly,
+				    jint permissions)
+{
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
+  if (!canon)
+    return false;
+
+  DWORD attrs = GetFileAttributes (canon);
+  if (attrs != INVALID_FILE_ATTRIBUTES)
+    {
+      // FIXME: implement
+      return false;
+    }
+  else
+    return false;
+}
+
 jboolean
 java::io::File::performMkdir (void)
 {