harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From arc...@apache.org
Subject svn commit: r398726 [5/6] - in /incubator/harmony/enhanced/classlibadapter: ./ trunk/ trunk/bin/ trunk/modules/ trunk/modules/kernel/ trunk/modules/kernel/src/ trunk/modules/kernel/src/main/ trunk/modules/kernel/src/main/java/ trunk/modules/kernel/src/...
Date Mon, 01 May 2006 23:11:49 GMT
Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessControlContext.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessControlContext.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessControlContext.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessControlContext.java Mon May  1 16:11:39 2006
@@ -0,0 +1,164 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.security;
+
+/**
+ * The vm vendor may choose to implement this class. The reference
+ * implementation must be used if the reference implementation of
+ * AccessController is used.
+ * 
+ * An AccessControlContext encapsulates the information which is needed by class
+ * AccessController to detect if a Permission would be granted at a particular
+ * point in a programs execution.
+ * 
+ */
+
+public final class AccessControlContext {
+	DomainCombiner domainCombiner;
+
+	ProtectionDomain[] domainsArray;
+
+	private static final SecurityPermission createAccessControlContext = new SecurityPermission(
+			"createAccessControlContext");
+
+	private static final SecurityPermission getDomainCombiner = new SecurityPermission(
+			"getDomainCombiner");
+
+	/**
+	 * Constructs a new instance of this class given an array of protection
+	 * domains.
+	 * 
+	 */
+	public AccessControlContext(ProtectionDomain[] context) {
+		int length = context.length;
+		int domainIndex = 0;
+		this.domainsArray = new ProtectionDomain[length];
+		next: for (int i = 0; i < length; i++) {
+			ProtectionDomain current = context[i];
+			for (int j = 0; j < i; j++)
+				if (current == this.domainsArray[j])
+					continue next;
+			this.domainsArray[domainIndex++] = current;
+		}
+		if (domainIndex != length) {
+			ProtectionDomain[] copy = new ProtectionDomain[domainIndex];
+			System.arraycopy(this.domainsArray, 0, copy, 0, domainIndex);
+			this.domainsArray = copy;
+		}
+	}
+
+	AccessControlContext(ProtectionDomain[] context, boolean ignored) {
+		domainsArray = context;
+	}
+
+	/**
+	 * Constructs a new instance of this class given a context and a
+	 * DomainCombiner
+	 */
+	public AccessControlContext(AccessControlContext acc,
+			DomainCombiner combiner) {
+		SecurityManager security = System.getSecurityManager();
+		if (security != null)
+			security.checkPermission(createAccessControlContext);
+		this.domainsArray = acc.domainsArray;
+		this.domainCombiner = combiner;
+	}
+
+	/**
+	 * Checks if the permission <code>perm</code> is allowed in this context.
+	 * All ProtectionDomains must grant the permission for it to be granted.
+	 * 
+	 * @param perm
+	 *            java.security.Permission the permission to check
+	 * @exception java.security.AccessControlException
+	 *                thrown when perm is not granted.
+	 */
+	public void checkPermission(Permission perm) throws AccessControlException {
+		if (perm == null)
+			throw new NullPointerException();
+		int i = domainsArray.length;
+		while (--i >= 0 && domainsArray[i].implies(perm))
+			;
+		if (i >= 0) {
+			throw new AccessControlException("Access Denied", perm);
+		}
+	}
+
+	/**
+	 * Compares the argument to the receiver, and answers true if they represent
+	 * the <em>same</em> object using a class specific comparison. In this
+	 * case, they must both be AccessControlContexts and contain the same
+	 * protection domains.
+	 * 
+	 * 
+	 * @param o
+	 *            the object to compare with this object
+	 * @return <code>true</code> if the object is the same as this object
+	 *         <code>false</code> if it is different from this object
+	 * @see #hashCode
+	 */
+	public boolean equals(Object o) {
+		if (this == o)
+			return true;
+		if (o == null || this.getClass() != o.getClass())
+			return false;
+		AccessControlContext otherContext = (AccessControlContext) o;
+		ProtectionDomain[] otherDomains = otherContext.domainsArray;
+		int length = domainsArray.length;
+		if (length != otherDomains.length)
+			return false;
+
+		next: for (int i = 0; i < length; i++) {
+			ProtectionDomain current = domainsArray[i];
+			for (int j = 0; j < length; j++)
+				if (current == otherDomains[j])
+					continue next;
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Answers an integer hash code for the receiver. Any two objects which
+	 * answer <code>true</code> when passed to <code>equals</code> must
+	 * answer the same value for this method.
+	 * 
+	 * 
+	 * @return the receiver's hash
+	 * 
+	 * @see #equals
+	 */
+	public int hashCode() {
+		int result = 0;
+		int i = domainsArray.length;
+		while (--i >= 0)
+			result ^= domainsArray[i].hashCode();
+		return result;
+	}
+
+	/**
+	 * Answers the DomainCombiner for the receiver.
+	 * 
+	 */
+	public DomainCombiner getDomainCombiner() {
+		SecurityManager security = System.getSecurityManager();
+		if (security != null)
+			security.checkPermission(getDomainCombiner);
+		return domainCombiner;
+	}
+
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessControlContext.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessController.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessController.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessController.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessController.java Mon May  1 16:11:39 2006
@@ -0,0 +1,278 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.security;
+
+/**
+ * This class must be implemented by the vm vendor, or the reference
+ * implementation can be used if the documented native is implemented.
+ * 
+ * Checks access to system resources. Supports marking of code as priveleged.
+ * Makes context snapshots to allow checking from other contexts.
+ * 
+ */
+
+public final class AccessController {
+	static {
+		// Initialize vm-internal caches
+		initializeInternal();
+	}
+
+    private static void initializeInternal() 
+    {
+        //fixit -- apparently this is not needed for simple "hello world" app.
+    }
+
+	/**
+	 * Prevents this class from being instantiated.
+	 */
+	private AccessController() {
+	}
+
+	/**
+	 * This native must be implemented to use the reference implementation of
+	 * this class. It is used by checkPermission() and getContext(), which call
+	 * this native with depth = 1.
+	 * 
+	 * Returns an array of ProtectionDomain from the classes on the stack, from
+	 * the specified depth up to the first privileged frame, or the end of the
+	 * stack if there is not a privileged frame. The array may be larger than
+	 * required, but must be null terminated. As bootstrap classes have all
+	 * permissions, bootstrap class frames SHOULD be skipped. Bootstrap class
+	 * frames MUST be skipped if the ProtectionDomain of bootstrap classes is
+	 * null. Duplicate ProtectionDomains SHOULD be removed.
+	 * 
+	 * The first element of the result is the AccessControlContext, which may be
+	 * null, either from the privileged frame, or from the current Thread if
+	 * there is not a privileged frame.
+	 * 
+	 * A privileged frame is any frame running one of the following methods:
+	 * 
+	 * <code><ul>
+	 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedAction;)Ljava/lang/Object;</li>
+	 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedExceptionAction;)Ljava/lang/Object;</li>
+	 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedAction;Ljava/security/AccessControlContext;)Ljava/lang/Object;</li>
+	 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedExceptionAction;Ljava/security/AccessControlContext;)Ljava/lang/Object;</li>
+	 * </ul></code>
+	 * 
+	 * @param depth
+	 *            The stack depth at which to start. Depth 0 is the current
+	 *            frame (the caller of this native).
+	 * 
+	 * @return an Object[] where the first element is AccessControlContext, and
+	 *         the other elements are ProtectionsDomain.
+	 */
+
+    private static Object[] getProtectionDomains(int depth) 
+    {
+        return null;  //this incorrect code is good enough for simple "hello world" demo
+    }
+
+	/**
+	 * Checks whether the running program is allowed to access the resource
+	 * being guarded by the given Permission argument.
+	 * 
+	 * 
+	 * @param perm
+	 *            the permission to check
+	 * @exception AccessControlException
+	 *                if access is not allowed.
+	 */
+	public static void checkPermission(Permission perm)
+			throws AccessControlException {
+		if (perm == null)
+			throw new NullPointerException();
+		Object[] domains = getProtectionDomains(1);
+		AccessControlContext acc = (AccessControlContext) domains[0];
+		ProtectionDomain[] pDomains = null;
+		if (acc != null && acc.domainCombiner != null) {
+			pDomains = acc.domainCombiner.combine(toArrayOfProtectionDomains(
+					domains, null), acc.domainsArray);
+		} else {
+			pDomains = toArrayOfProtectionDomains(domains, acc);
+		}
+		for (int i = 0, length = pDomains.length; i < length; i++) {
+			if (!pDomains[i].implies(perm)) {
+				throw new AccessControlException("Access Denied " + perm, perm);
+			}
+		}
+	}
+
+	/**
+	 * Used to keep the context live during doPrivileged().
+	 * 
+	 * 
+	 * @see #doPrivileged(PrivilegedAction, AccessControlContext)
+	 */
+	private static void keepalive(AccessControlContext context) {
+	}
+
+	/**
+	 * Answers the access controller context of the current thread, including
+	 * the inherited ones. It basically retrieves all the protection domains
+	 * from the calling stack and creates an <code>AccessControlContext</code>
+	 * with them.
+	 * 
+	 * 
+	 * @see AccessControlContext
+	 */
+	public static AccessControlContext getContext() {
+		Object[] domains = getProtectionDomains(1);
+		AccessControlContext acc = (AccessControlContext) domains[0];
+		ProtectionDomain[] pDomains = null;
+		if (acc != null && acc.domainCombiner != null) {
+			pDomains = acc.domainCombiner.combine(toArrayOfProtectionDomains(
+					domains, null), acc.domainsArray);
+			AccessControlContext result = new AccessControlContext(pDomains,
+					false);
+			result.domainCombiner = acc.domainCombiner;
+			return result;
+		}
+		return new AccessControlContext(
+				toArrayOfProtectionDomains(domains, acc), false);
+	}
+
+	private static ProtectionDomain[] toArrayOfProtectionDomains(
+			Object[] domains, AccessControlContext acc) {
+		int len = 0, size = domains.length - 1;
+		int extra = acc == null ? 0 : acc.domainsArray.length;
+		ProtectionDomain[] answer = new ProtectionDomain[size + extra];
+		for (int i = 1; i <= size; i++) {
+			boolean found = false;
+			if ((answer[len] = (ProtectionDomain) domains[i]) == null)
+				break;
+			if (acc != null) {
+				for (int j = 0; j < acc.domainsArray.length; j++) {
+					if (answer[len] == acc.domainsArray[j]) {
+						found = true;
+						break;
+					}
+				}
+			}
+			if (!found)
+				len++;
+		}
+		if (len == 0 && acc != null)
+			return acc.domainsArray;
+		else if (len < size) {
+			ProtectionDomain[] copy = new ProtectionDomain[len + extra];
+			System.arraycopy(answer, 0, copy, 0, len);
+			answer = copy;
+		}
+		if (acc != null)
+			System.arraycopy(acc.domainsArray, 0, answer, len,
+					acc.domainsArray.length);
+		return answer;
+	}
+
+	/**
+	 * Performs the privileged action specified by <code>action</code>.
+	 * <p>
+	 * When permission checks are made, if the permission has been granted by
+	 * all frames below and including the one representing the call to this
+	 * method, then the permission is granted. In otherwords, the check stops
+	 * here.
+	 * 
+	 * Any unchecked exception generated by this method will propagate up the
+	 * chain.
+	 * 
+	 * 
+	 * @see #doPrivileged(PrivilegedAction)
+	 */
+	public static Object doPrivileged(PrivilegedAction action) {
+		return action.run();
+	}
+
+	/**
+	 * Performs the privileged action specified by <code>action</code>.
+	 * <p>
+	 * When permission checks are made, if the permission has been granted by
+	 * all frames below and including the one representing the call to this
+	 * method, then the permission is granted iff it is granted by the
+	 * AccessControlContext <code>context</code>. In otherwords, no more
+	 * checking of the current stack is performed. Instead, the passed in
+	 * context is checked.
+	 * 
+	 * Any unchecked exception generated by this method will propagate up the
+	 * chain.
+	 * 
+	 * 
+	 * @see #doPrivileged(PrivilegedAction)
+	 */
+	public static Object doPrivileged(PrivilegedAction action,
+			AccessControlContext context) {
+		Object result = action.run();
+		keepalive(context);
+		return result;
+	}
+
+	/**
+	 * Performs the privileged action specified by <code>action</code>.
+	 * <p>
+	 * When permission checks are made, if the permission has been granted by
+	 * all frames below and including the one representing the call to this
+	 * method, then the permission is granted. In otherwords, the check stops
+	 * here.
+	 * 
+	 * Any unchecked exception generated by this method will propagate up the
+	 * chain. However, checked exceptions will be caught an re-thrown as
+	 * PrivilegedActionExceptions
+	 * 
+	 * 
+	 * @see #doPrivileged(PrivilegedAction)
+	 */
+	public static Object doPrivileged(PrivilegedExceptionAction action)
+			throws PrivilegedActionException {
+		try {
+			return action.run();
+		} catch (RuntimeException ex) {
+			throw ex;
+		} catch (Exception ex) {
+			throw new PrivilegedActionException(ex);
+		}
+	}
+
+	/**
+	 * Performs the privileged action specified by <code>action</code>.
+	 * <p>
+	 * When permission checks are made, if the permission has been granted by
+	 * all frames below and including the one representing the call to this
+	 * method, then the permission is granted iff it is granted by the
+	 * AccessControlContext <code>context</code>. In otherwords, no more
+	 * checking of the current stack is performed. Instead, the passed in
+	 * context is checked.
+	 * 
+	 * Any unchecked exception generated by this method will propagate up the
+	 * chain. However, checked exceptions will be caught an re-thrown as
+	 * PrivilegedActionExceptions
+	 * 
+	 * 
+	 * @see #doPrivileged(PrivilegedAction)
+	 */
+	public static Object doPrivileged(PrivilegedExceptionAction action,
+			AccessControlContext context) throws PrivilegedActionException {
+		try {
+			Object result = action.run();
+			keepalive(context);
+			return result;
+		} catch (RuntimeException ex) {
+			throw ex;
+		} catch (Exception ex) {
+			throw new PrivilegedActionException(ex);
+		}
+	}
+
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/kernel/src/main/java/java/security/AccessController.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/luni/src/main/java/java/io/FileDescriptor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/luni/src/main/java/java/io/FileDescriptor.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/luni/src/main/java/java/io/FileDescriptor.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/luni/src/main/java/java/io/FileDescriptor.java Mon May  1 16:11:39 2006
@@ -0,0 +1,94 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.io; 
+
+
+/**
+ * FileDescriptor is the lowest level representation of a File, Device, or
+ * Socket. You can create any of the IO classes which take a FileDescriptor as
+ * an argument by querying an open Socket or File for the FileDescriptor.
+ * <p>
+ * The FileDescriptor class also contains static fields representing Standard
+ * Input, Output and Error. You can use these directly if desired but it is
+ * recommended you go through System.in, System.out, and System.err streams
+ * respectively.
+ * <p>
+ * Applications should not create new FileDescriptors.
+ * 
+ * @see FileInputStream#getFD()
+ * @see FileOutputStream#getFD()
+ * @see RandomAccessFile#getFD()
+ */
+public final class FileDescriptor {
+	/** FileDescriptor representing Standard In */
+	public static final FileDescriptor in = new FileDescriptor();
+
+	/** FileDescriptor representing Standard Out */
+	public static final FileDescriptor out = new FileDescriptor();
+
+	/** FileDescriptor representing Standard Error */
+	public static final FileDescriptor err = new FileDescriptor();
+
+	/**
+	 * Represents a link to any underlying OS resources for this FileDescriptor.
+	 * A value of -1 indicates that this FileDescriptor is invalid.
+	 */
+	long descriptor = -1;
+
+	//private static native void oneTimeInitialization();  //fixit --- this line was replaced with the non-native code below
+    static int initCount;
+    private static void oneTimeInitialization()             //fixit ---- this code is sufficient to allow simple "hello world" demo to run
+    {
+        initCount++;
+    }
+
+	static {
+		in.descriptor = 0;
+		out.descriptor = 1;
+		err.descriptor = 2;
+
+		oneTimeInitialization();
+	}
+
+	/**
+	 * Constructs a new FileDescriptor containing an invalid handle. This
+	 * constructor does nothing interesting. Provided for signature
+	 * compatibility.
+	 * 
+	 */
+	public FileDescriptor() {
+		super();
+	}
+
+	/**
+	 * Ensures that data which is buffered within the underlying implementation
+	 * is written out to the appropriate device before returning.
+	 * 
+	 * @throws SyncFailedException
+	 *             when the operation fails
+	 */
+	public native void sync() throws SyncFailedException;
+
+	/**
+	 * Answers a boolean indicating whether or not this FileDescriptor is valid.
+	 * 
+	 * @return <code>true</code> if this FileDescriptor is valid,
+	 *         <code>false</code> otherwise
+	 */
+	public native boolean valid();
+
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/luni/src/main/java/java/io/FileDescriptor.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSFileSystem.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSFileSystem.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSFileSystem.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSFileSystem.java Mon May  1 16:11:39 2006
@@ -0,0 +1,277 @@
+/* Copyright 2004, 2006 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ibm.platform;
+
+import java.io.FileDescriptor;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * This is the portable implementation of the file system interface.
+ * 
+ */
+public class OSFileSystem extends OSComponent implements IFileSystem {
+
+	/**
+	 * 
+	 */
+	public OSFileSystem() {
+		super();
+	}
+
+	private final void validateLockArgs(int type, long start, long length) {
+		if ((type != IFileSystem.SHARED_LOCK_TYPE)
+				&& (type != IFileSystem.EXCLUSIVE_LOCK_TYPE)) {
+			throw new IllegalArgumentException("Illegal lock type requested."); //$NON-NLS-1$
+		}
+
+		// Start position
+		if (start < 0) {
+			throw new IllegalArgumentException(
+					"Lock start position must be non-negative"); //$NON-NLS-1$
+		}
+
+		// Length of lock stretch
+		if (length < 0) {
+			throw new IllegalArgumentException(
+					"Lock length must be non-negative"); //$NON-NLS-1$
+		}
+	}
+
+    private int lockImpl(long fileDescriptor, long start, long length,
+        int type, boolean wait) 
+    {
+        System.out.println("OSFileSystem.lockImpl() is not implemented yet");
+        return 0; //fixit -- returning a null is incorrect but it allows simple "hello world" to run
+    }
+
+    public int getPageSize() 
+    {
+        return 1024*4; //fixit -- just a wild guess. Need to find out what this value is supposed to be
+    }   
+
+	public boolean lock(long fileDescriptor, long start, long length, int type,
+			boolean waitFlag) throws IOException {
+		// Validate arguments
+		validateLockArgs(type, start, length);
+		int result = lockImpl(fileDescriptor, start, length, type, waitFlag);
+		return result != -1;
+	}
+
+    private int unlockImpl(long fileDescriptor, long start, long length) 
+    {
+        System.out.println("OSFileSystem.unlockImpl() is not implemented yet");
+        return 0; //fixit -- not yet implemented
+    }
+
+	public void unlock(long fileDescriptor, long start, long length)
+			throws IOException {
+		// Validate arguments
+		validateLockArgs(IFileSystem.SHARED_LOCK_TYPE, start, length);
+		int result = unlockImpl(fileDescriptor, start, length);
+		if (result == -1) {
+			throw new IOException();
+		}
+	}
+
+    private native int fflushImpl(long fd, boolean metadata);
+
+	public void fflush(long fileDescriptor, boolean metadata)
+			throws IOException {
+		int result = fflushImpl(fileDescriptor, metadata);
+		if (result == -1) {
+			throw new IOException();
+		}
+	}
+
+	/*
+	 * File position seeking.
+	 */
+
+    private native long seekImpl(long fd, long offset, int whence);
+
+	public long seek(long fileDescriptor, long offset, int whence)
+			throws IOException {
+		long pos = seekImpl(fileDescriptor, offset, whence);
+		if (pos == -1) {
+			throw new IOException();
+		}
+		return pos;
+	}
+
+	/*
+	 * Direct read/write APIs work on addresses.
+	 */
+    private long readDirectImpl(long fileDescriptor, long address,
+        int offset, int length) 
+    {
+        System.out.println("OSFileSystem.readDirectImpl() is not yet implemented");
+        return 0L;
+    }
+
+	public long readDirect(long fileDescriptor, long address, int offset,
+			int length) throws IOException {
+		long bytesRead = readDirectImpl(fileDescriptor, address, offset, length);
+		if (bytesRead < -1) {
+			throw new IOException();
+		}
+		return bytesRead;
+	}
+
+    private long writeDirectImpl(long fileDescriptor, long address,
+        int offset, int length) 
+    {
+        System.out.println("OSFileSystem.writeDirectImpl() is not yet implemented");
+        return 0;
+    }
+
+	public long writeDirect(long fileDescriptor, long address, int offset,
+			int length) throws IOException {
+		long bytesWritten = writeDirectImpl(fileDescriptor, address, offset,
+				length);
+		if (bytesWritten < 0) {
+			throw new IOException();
+		}
+		return bytesWritten;
+	}
+
+	/*
+	 * Indirect read/writes work on byte[]'s
+	 */
+    private native long readImpl(long fileDescriptor, byte[] oneByteArray);
+
+	public long read(long fileDescriptor, byte[] bytes, int offset, int length)
+			throws IOException {
+        byte [] oneByteArray = new byte[1];
+        for (int xx = offset; xx < offset + length; xx++) 
+        {
+            long stat = readImpl(fileDescriptor, oneByteArray);
+            if (stat == -1) 
+            {
+                System.out.println("OSFileSystem.read() -- error");
+                throw new IOException();
+            }
+            bytes[xx] = oneByteArray[0];
+        }
+		return length;
+	}
+
+    private native void writeImpl(long fileDescriptor, int theCharacterToBeWritten) ; //fixit -- need to allow for different fileDescriptor's
+
+	public long write(long fileDescriptor, byte[] bytes, int offset, int length)
+			throws IOException {
+        for (int xx = offset; xx < offset + length; xx++) 
+        {
+            int target = (int)bytes[xx];
+            writeImpl(fileDescriptor, target);
+        }
+		//if (bytesWritten < 0) {
+		//	throw new IOException();
+		//}
+        long bytesWritten = length;
+		return bytesWritten;
+        
+	}
+
+	/*
+	 * Scatter/gather calls.
+	 */
+	public long readv(long fileDescriptor, long[] addresses, int[] offsets,
+			int[] lengths, int size) throws IOException {
+		long bytesRead = readvImpl(fileDescriptor, addresses, offsets, lengths,
+				size);
+		if (bytesRead < -1) {
+			throw new IOException();
+		}
+		return bytesRead;
+	}
+
+    private long readvImpl(long fileDescriptor, long[] addresses,
+        int[] offsets, int[] lengths, int size) 
+    {
+        System.out.println("OSFileSystem.readvImpl() is not yet implemented");
+        return 0L;
+    }
+
+	public long writev(long fileDescriptor, long[] addresses, int[] offsets,
+			int[] lengths, int size) throws IOException {
+		long bytesWritten = writevImpl(fileDescriptor, addresses, offsets,
+				lengths, size);
+		if (bytesWritten < 0) {
+			throw new IOException();
+		}
+		return bytesWritten;
+	}
+
+    private long writevImpl(long fileDescriptor, long[] addresses,
+        int[] offsets, int[] lengths, int size) 
+    {
+        System.out.println("OSFileSystem.writevImpl() is not yet implemented");
+        return 0L;
+    }
+
+    private native int closeImpl(long fileDescriptor);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.ibm.platform.IFileSystem#close(long)
+	 */
+	public void close(long fileDescriptor) throws IOException {
+		int rc = closeImpl(fileDescriptor);
+		if (rc == -1) {
+			throw new IOException();
+		}
+	}
+
+	public void truncate(long fileDescriptor, long size) throws IOException {
+		int rc = truncateImpl(fileDescriptor, size);
+		if (rc < 0) {
+			throw new IOException();
+		}
+	}
+
+    private native int truncateImpl(long fileDescriptor, long size);
+
+	public long open(byte[] fileName, int mode) throws FileNotFoundException {
+		if (fileName == null) {
+			throw new NullPointerException();
+		}
+		long handler = openImpl(fileName, mode);
+		if (handler < 0) {
+			throw new FileNotFoundException();
+		}
+		return handler;
+	}
+
+    private native long openImpl(byte[] fileName, int mode);
+
+	public long transfer(long fileHandler, FileDescriptor socketDescriptor,
+			long offset, long count) throws IOException {
+		long result = transferImpl(fileHandler, socketDescriptor, offset, count);
+		if (result < 0)
+			throw new IOException();
+		return result;
+	}
+
+    private long transferImpl(long fileHandler,
+        FileDescriptor socketDescriptor, long offset, long count) 
+    {
+        System.out.println("OSFileSystem.transferImpl() is not yet implemented");
+        return 0L;
+    }
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSFileSystem.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSMemory.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSMemory.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSMemory.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSMemory.java Mon May  1 16:11:39 2006
@@ -0,0 +1,698 @@
+/* Copyright 2004, 2006 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ibm.platform;
+
+import java.io.IOException;
+
+import org.apache.harmony.luni.util.NotYetImplementedException;
+
+import com.ibm.platform.struct.PlatformAddress;
+
+// import com.ibm.oti.vm.VM;
+
+/**
+ * This class enables direct access to OS memory.
+ * <p>
+ * Methods that take OS addresses define such parameters as a Java
+ * <code>long</code>. The <code>long</code> value is interpreted based on
+ * the underlying platform pointer size, such that only the lowest significant
+ * <code>POINTER_SIZE</code> bytes of the <code>long</code> value are used.
+ * In practice this means that methods on 64-bit platforms use the full eight
+ * bytes of the address parameter, and on 32-bit platforms the same methods are
+ * truncated to use only the low four bytes.
+ * </p>
+ * <p>
+ * Methods that return OS addresses define the return type to be a Java
+ * <code>long</code>. If the platform pointer size is less than eight bytes
+ * the OS address value is zero-extended to an eight-byte int to correspond to
+ * the subsequent interpretation of that jlong as an OS address as defined
+ * above.
+ * </p>
+ */
+final class OSMemory extends OSComponent implements IMemorySystem 
+{
+
+    /**
+     * Defines the size, in bytes, of a native pointer type for the underlying
+     * platform. This will be 4 (for 32-bit machines) or 8 (for 64-bit
+     * machines).
+     */
+    public static final int POINTER_SIZE;
+
+    /**
+     * Defines the natural byte order for this machine.
+     */
+    public static final Endianness NATIVE_ORDER;
+
+    private static final OSMemory singleton = new OSMemory();
+
+    static 
+    {
+        // FIXME: OSMemory, OSFileSystem, OSNetwork, should be moved to luni
+        System.loadLibrary("hynio");
+        POINTER_SIZE = getPointerSizeImpl();
+
+        if (isLittleEndianImpl()) 
+        {
+            NATIVE_ORDER = Endianness.LITTLE_ENDIAN;
+        } 
+        else 
+        {
+            NATIVE_ORDER = Endianness.BIG_ENDIAN;
+        }
+    }
+
+    public static OSMemory getOSMemory() 
+    {
+        /*
+         * if (VM.callerClassLoader() != null) { throw new SecurityException(); }
+         */
+        return singleton;
+    }
+
+    /**
+     * This class is not designed to be publically instantiated.
+     * 
+     * @see #getOSMemory()
+     */
+    OSMemory() 
+    {
+        super();
+    }
+
+    /**
+     * Answers whether the byte order of this machine is little endian or not..
+     * 
+     * @return <code>false</code> for Big Endian, and
+     *         <code>true</code. for Little Endian.
+     */
+    public static boolean isLittleEndianImpl() {  //fixit -- this is sufficient for simple "hello world" but is wrong
+        return true;
+    }
+
+	public boolean isLittleEndian() {
+		return isLittleEndianImpl();
+	}
+
+	/**
+	 * Answers the natural byte order for this machine.
+	 * 
+	 * @return the native byte order for the current platform.
+	 */
+	public Endianness getNativeOrder() {
+		return NATIVE_ORDER;
+	}
+
+	/**
+	 * Answers the size of a native pointer type for the underlying platform.
+	 * 
+	 * @return the size of a pointer, in bytes.
+	 */
+    private static int getPointerSizeImpl() 
+    { //fixit -- need to account for 64-bit machines
+        return 4;
+    }
+
+
+	public int getPointerSize() {
+		return POINTER_SIZE;
+	}
+
+	/**
+	 * Allocates and returns a pointer to space for a memory block of
+	 * <code>length</code> bytes. The space is uninitialized and may be larger
+	 * than the number of bytes requested; however, the guaranteed usable memory
+	 * block is exactly <code>length</code> bytes long.
+	 * 
+	 * @param length
+	 *            number of bytes requested.
+	 * @return the address of the start of the memory block.
+	 * @throws OutOfMemoryError
+	 *             if the request cannot be satisfied.
+	 */
+    public long malloc(long length) throws OutOfMemoryError 
+    {
+        return 0L;  //fixit -- returning zero is good enough for simple "hello world" demo
+    }
+
+	/**
+	 * Deallocates space for a memory block that was previously allocated by a
+	 * call to {@link #malloc(long) malloc(long)}. The number of bytes freed is
+	 * identical to the number of bytes acquired when the memory block was
+	 * allocated. If <code>address</code> is zero the method does nothing.
+	 * <p>
+	 * Freeing a pointer to a memory block that was not allocated by
+	 * <code>malloc()</code> has unspecified effect.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the address of the memory block to deallocate.
+	 */
+    public void free(long address) 
+    {
+        //fixit -- ignoring the "freeing" of memory is good enough for simple "hello world" app
+    }
+
+	/**
+	 * Places <code>value</code> into first <code>length</code> bytes of the
+	 * memory block starting at <code>address</code>.
+	 * <p>
+	 * The behavior is unspecified if
+	 * <code>(address ... address + length)</code> is not wholly within the
+	 * range that was previously allocated using <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the address of the first memory location.
+	 * @param value
+	 *            the byte value to set at each location.
+	 * @param length
+	 *            the number of byte-length locations to set.
+	 */
+    public void memset(long address, byte value, long length) 
+    {
+        //fixit -- a "nop" memset is good enough for simple "hello world" app
+    }
+
+	/**
+	 * Copies <code>length</code> bytes from <code>srcAddress</code> to
+	 * <code>destAddress</code>. Where any part of the source memory block
+	 * and the destination memory block overlap <code>memmove()</code> ensures
+	 * that the original source bytes in the overlapping region are copied
+	 * before being overwritten.
+	 * <p>
+	 * The behavior is unspecified if
+	 * <code>(srcAddress ... srcAddress + length)</code> and
+	 * <code>(destAddress ... destAddress + length)</code> are not both wholly
+	 * within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param destAddress
+	 *            the address of the destination memory block.
+	 * @param srcAddress
+	 *            the address of the source memory block.
+	 * @param length
+	 *            the number of bytes to move.
+	 */
+    public void memmove(long destAddress, long srcAddress, long length) 
+    {
+        //fixit -- a "nop" memmove is good enough for simple "hello world" app
+    }
+
+	/**
+	 * Copies <code>length</code> bytes from the memory block at
+	 * <code>address</code> into the byte array <code>bytes</code> starting
+	 * at element <code>offset</code> within the byte array.
+	 * <p>
+	 * The behavior of this method is undefined if the range
+	 * <code>(address ... address + length)</code> is not within a memory
+	 * block that was allocated using {@link #malloc(long) malloc(long)}.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the address of the OS memory block from which to copy bytes.
+	 * @param bytes
+	 *            the byte array into which to copy the bytes.
+	 * @param offset
+	 *            the index of the first element in <code>bytes</code> that
+	 *            will be overwritten.
+	 * @param length
+	 *            the total number of bytes to copy into the byte array.
+	 * @throws NullPointerException
+	 *             if <code>bytes</code> is <code>null</code>.
+	 * @throws IndexOutOfBoundsException
+	 *             if <code>offset + length > bytes.length</code>.
+	 */
+    public void getByteArray(long address, byte[] bytes, int offset,
+        int length) throws NullPointerException, IndexOutOfBoundsException
+    {
+        //fixit -- a "nop" is good enough to allow simple "hello world" to run
+    }
+
+	/**
+	 * Copies <code>length</code> bytes from the byte array <code>bytes</code>
+	 * into the memory block at <code>address</code>, starting at element
+	 * <code>offset</code> within the byte array.
+	 * <p>
+	 * The behavior of this method is undefined if the range
+	 * <code>(address ... address + length)</code> is not within a memory
+	 * block that was allocated using {@link #malloc(long) malloc(long)}.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the address of the OS memory block into which to copy the
+	 *            bytes.
+	 * @param bytes
+	 *            the byte array from which to copy the bytes.
+	 * @param offset
+	 *            the index of the first element in <code>bytes</code> that
+	 *            will be read.
+	 * @param length
+	 *            the total number of bytes to copy from <code>bytes</code>
+	 *            into the memory block.
+	 * @throws NullPointerException
+	 *             if <code>bytes</code> is <code>null</code>.
+	 * @throws IndexOutOfBoundsException
+	 *             if <code>offset + length > bytes.length</code>.
+	 */
+    public void setByteArray(long address, byte[] bytes, int offset,
+        int length) throws NullPointerException, IndexOutOfBoundsException 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	// Primitive get & set methods
+
+	/**
+	 * Gets the value of the single byte at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>address</code> is not in the range
+	 * that was previously allocated using <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the byte.
+	 * @return the byte value.
+	 */
+    public byte getByte(long address) 
+    {
+        return 0; //returning zero is good enough to allow simple "hello world" demo
+    }
+
+	/**
+	 * Sets the given single byte value at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>address</code> is not in the range
+	 * that was previously allocated using <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the address at which to set the byte value.
+	 * @param value
+	 *            the value to set.
+	 */
+    public void setByte(long address, byte value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	/**
+	 * Gets the value of the signed two-byte integer stored in platform byte
+	 * order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 2)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the two-byte value.
+	 * @return the value of the two-byte integer as a Java <code>short</code>.
+	 */
+    public short getShort(long address) 
+    {
+        return 0; //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public short getShort(long address, Endianness endianness) {
+		return (endianness == NATIVE_ORDER) ? getShort(address)
+				: swap(getShort(address));
+	}
+
+	/**
+	 * Sets the value of the signed two-byte integer at the given address in
+	 * platform byte order.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 2)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the two-byte value.
+	 * @param value
+	 *            the value of the two-byte integer as a Java <code>short</code>.
+	 */
+    public void setShort(long address, short value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void setShort(long address, short value, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			setShort(address, value);
+		} else {
+			setShort(address, swap(value));
+		}
+	}
+
+	/**
+	 * Gets the value of the signed four-byte integer stored in platform
+	 * byte-order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 4)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the four-byte value.
+	 * @return the value of the four-byte integer as a Java <code>int</code>.
+	 */
+    public  int getInt(long address) 
+    {
+        return 0; //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public int getInt(long address, Endianness endianness) {
+		return (endianness == NATIVE_ORDER) ? getInt(address)
+				: swap(getInt(address));
+	}
+
+	/**
+	 * Sets the value of the signed four-byte integer at the given address in
+	 * platform byte order.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 4)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the four-byte value.
+	 * @param value
+	 *            the value of the four-byte integer as a Java <code>int</code>.
+	 */
+    public void setInt(long address, int value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void setInt(long address, int value, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			setInt(address, value);
+		} else {
+			setInt(address, swap(value));
+		}
+	}
+
+	/**
+	 * Gets the value of the signed eight-byte integer stored in platform byte
+	 * order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 8)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @return the value of the eight-byte integer as a Java <code>long</code>.
+	 */
+    public long getLong(long address) 
+    {
+        return 0L; // fixit --- this is sufficient for simple "hello world" but is wrong
+    }
+
+	public long getLong(long address, Endianness endianness) {
+		return (endianness == NATIVE_ORDER) ? getLong(address)
+				: swap(getLong(address));
+	}
+
+	/**
+	 * Sets the value of the signed eight-byte integer at the given address in
+	 * the platform byte order.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 8)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @param value
+	 *            the value of the eight-byte integer as a Java
+	 *            <code>long</code>.
+	 */
+    public void setLong(long address, long value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void setLong(long address, long value, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			setLong(address, value);
+		} else {
+			setLong(address, swap(value));
+		}
+	}
+
+	/**
+	 * Gets the value of the IEEE754-format four-byte float stored in platform
+	 * byte order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 4)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @return the value of the four-byte float as a Java <code>float</code>.
+	 */
+    public float getFloat(long address) 
+    {
+        return (float)0.0; //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public float getFloat(long address, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			return getFloat(address);
+		}
+		int floatBits = swap(getInt(address));
+		return Float.intBitsToFloat(floatBits);
+	}
+
+	/**
+	 * Sets the value of the IEEE754-format four-byte float stored in platform
+	 * byte order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 4)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @param value
+	 *            the value of the four-byte float as a Java <code>float</code>.
+	 */
+    public void setFloat(long address, float value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void setFloat(long address, float value, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			setFloat(address, value);
+		} else {
+			int floatBits = Float.floatToIntBits(value);
+			setInt(address, swap(floatBits));
+		}
+	}
+
+	/**
+	 * Gets the value of the IEEE754-format eight-byte float stored in platform
+	 * byte order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 8)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @return the value of the eight-byte float as a Java <code>double</code>.
+	 */
+    public double getDouble(long address) 
+    {
+        return 0.0; //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public double getDouble(long address, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			return getDouble(address);
+		}
+		long doubleBits = swap(getLong(address));
+		return Double.longBitsToDouble(doubleBits);
+	}
+
+	/**
+	 * Sets the value of the IEEE754-format eight-byte float store in platform
+	 * byte order at the given address.
+	 * <p>
+	 * The behavior is unspecified if <code>(address ... address + 8)</code>
+	 * is not wholly within the range that was previously allocated using
+	 * <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the eight-byte value.
+	 * @param value
+	 *            the value of the eight-byte float as a Java
+	 *            <code>double</code>.
+	 */
+    public void setDouble(long address, double value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void setDouble(long address, double value, Endianness endianness) {
+		if (endianness == NATIVE_ORDER) {
+			setDouble(address, value);
+		} else {
+			long doubleBits = Double.doubleToLongBits(value);
+			setLong(address, swap(doubleBits));
+		}
+	}
+
+	/**
+	 * Gets the value of the platform pointer at the given address.
+	 * <p>
+	 * The length of the platform pointer is defined by
+	 * <code>POINTER_SIZE</code>.
+	 * </p>
+	 * The behavior is unspecified if
+	 * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+	 * the range that was previously allocated using <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the platform pointer.
+	 * @return the value of the platform pointer as a Java <code>long</code>.
+	 */
+    public long getAddress(long address) 
+    {
+        return 0L;  //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	/**
+	 * Sets the value of the platform pointer at the given address.
+	 * <p>
+	 * The length of the platform pointer is defined by
+	 * <code>POINTER_SIZE</code>. This method only sets
+	 * <code>POINTER_SIZE</code> bytes at the given address.
+	 * </p>
+	 * The behavior is unspecified if
+	 * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+	 * the range that was previously allocated using <code>malloc()</code>.
+	 * </p>
+	 * 
+	 * @param address
+	 *            the platform address of the start of the platform pointer.
+	 * @param value
+	 *            the value of the platform pointer as a Java <code>long</code>.
+	 */
+    public void setAddress(long address, long value) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	/*
+	 * Memory mapped file
+	 */
+    private long mmapImpl(long fileDescriptor, long alignment,
+        long size, int mapMode) 
+    {
+        return 0L;    //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public PlatformAddress mmap(long fileDescriptor, long alignment, long size,
+			int mapMode) throws IOException {
+		throw new NotYetImplementedException();
+//		long address = mmapImpl(fileDescriptor, alignment, size, mapMode);
+//		if (address == -1) {
+//			throw new IOException();
+//		}
+//		return PlatformAddress.on(address, true);
+	}
+
+    private void unmapImpl(long addr) 
+    {
+        //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void unmap(PlatformAddress addr) {
+		long osAddr = addr.toLong();
+		unmapImpl(osAddr);
+	}
+
+	public void load(PlatformAddress addr, long size) {
+		// WIN32: virtualLock, need
+		// Linux:
+		loadImpl(addr.toLong(), size);
+	}
+
+    private int loadImpl(long l, long size) 
+    {
+        return 0;         //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public boolean isLoaded(PlatformAddress addr, long size) {
+		return size == 0 ? true : isLoadedImpl(addr.toLong(), size);
+	}
+
+    private boolean isLoadedImpl(long l, long size) 
+    {
+        return false;          //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	public void flush(PlatformAddress addr, long size) {
+		flushImpl(addr.toLong(), size);
+	}
+
+    private int flushImpl(long l, long size) 
+    {
+        return 0;         //a "nop" is good enough to allow simple "hello world" demo
+    }
+
+	/*
+	 * Helper methods to change byte order.
+	 */
+	private short swap(short value) {
+		int topEnd = value << 8;
+		int btmEnd = (value >> 8) & 0xFF;
+		return (short) (topEnd | btmEnd);
+	}
+
+	private int swap(int value) {
+		short left = (short) (value >> 16);
+		short right = (short) value;
+		int topEnd = swap(right) << 16;
+		int btmEnd = swap(left) & 0xFFFF;
+		return topEnd | btmEnd;
+	}
+
+	private long swap(long value) {
+		int left = (int) (value >> 32);
+		int right = (int) value;
+		long topEnd = ((long) swap(right)) << 32;
+		long btmEnd = swap(left) & 0xFFFFFFFFL;
+		return topEnd | btmEnd;
+	}
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/com/ibm/platform/OSMemory.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/java/nio/Buffer.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/java/nio/Buffer.java?rev=398726&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/java/nio/Buffer.java (added)
+++ incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/java/nio/Buffer.java Mon May  1 16:11:39 2006
@@ -0,0 +1,291 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.nio;
+
+
+/**
+ * A buffer is a list of elements of a specific primitive type.
+ * <p>
+ * A buffer can be described by following properties:
+ * <ul>
+ * <li>Capacity, is the number of elements a buffer can hold. Capacity is no
+ * less than zero and never changes.</li>
+ * <li>Posotion, is a cursor of this buffer. Elements are read or write at the
+ * position if you do not specify an index explicitly. Position is no less than
+ * zero and no greater than the limit.</li>
+ * <li>Limit controls the scope of accessible elements. You can only read or
+ * write elements from index zero to <code>limit - 1</code>. Accessing
+ * elements out of the scope will cause exception. Limit is no less than zero
+ * and no greater than capacity.</li>
+ * <li>Mark, is used to remember the current position, so that you can reset
+ * the position later. Mark is no less than zero and no greater than position.</li>
+ * <li>A buffer can be readonly or read-write. Trying to modify the elements of
+ * a readonly buffer will cause <code>ReadOnlyBufferException</code>, while
+ * changing the position, limit and mark of a readonly buffer is OK.</li>
+ * <li>A buffer can be direct or indirect. A direct buffer will try its best to
+ * take advantage of native memory APIs and it may not stay in java heap, thus
+ * not affected by GC.</li>
+ * </ul>
+ * </p>
+ * <p>
+ * Buffers are not thread-safe. If concurrent access to a buffer instance is
+ * required, then the callers are responsible to take care of the
+ * synchronization issues.
+ * </p>
+ * 
+ */
+public abstract class Buffer {
+
+    gnu.classpath.Pointer address; //address, "Lgnu/classpath/Pointer;"
+    int cap;  //cap, "I" -- this is added because Apache JCHEVM expects this field
+	/**
+	 * <code>UNSET_MARK</code> means the mark has not been set.
+	 */
+	final static int UNSET_MARK = -1;
+
+	/**
+	 * The capacity of this buffer, which never change.
+	 */
+	final int capacity;
+
+	/**
+	 * <code>limit - 1</code> is the last element that can be read or write.
+	 * Limit must be no less than zero and no greater than <code>capacity</code>.
+	 */
+	int limit;
+
+	/**
+	 * Mark is the position will be set when <code>reset()</code> is called.
+	 * Mark is not set by default. Mark is always no less than zero and no
+	 * greater than <code>position</code>.
+	 */
+	int mark = UNSET_MARK;
+
+	/**
+	 * The current position of this buffer. Position is always no less than zero
+	 * and no greater than <code>limit</code>.
+	 */
+	int position = 0;
+
+	/**
+	 * Construct a buffer with the specified capacity.
+	 * 
+	 * @param capacity
+	 *            The capacity of this buffer
+	 */
+	Buffer(int capacity) {
+		super();
+		if (capacity < 0) {
+			throw new IllegalArgumentException();
+		}
+		this.capacity = this.limit = capacity;
+	}
+
+	/**
+	 * Returns the capacity of this buffer.
+	 * 
+	 * @return The number of elements that are contained in this buffer. 
+	 */
+	public final int capacity() {
+		return capacity;
+	}
+
+	/**
+	 * Clears this buffer.
+	 * <p>
+	 * While the content of this buffer is not changed the following internal 
+	 * changes take place : the current position is reset back to the start of the buffer, 
+	 * the value of the buffer limit is made equal to the capacity and mark is unset.    
+	 * </p>
+	 * 
+	 * @return This buffer
+	 */
+	public final Buffer clear() {
+		position = 0;
+		mark = UNSET_MARK;
+		limit = capacity;
+		return this;
+	}
+
+	/**
+	 * Flips this buffer.
+	 * <p>
+	 * The limit is set to the current position, then the position is set to
+	 * zero, and the mark is cleared.
+	 * </p>
+	 * <p>
+	 * The content of this buffer is not changed.
+	 * </p>
+	 * 
+	 * @return This buffer
+	 */
+	public final Buffer flip() {
+		limit = position;
+		position = 0;
+		mark = UNSET_MARK;
+		return this;
+	}
+
+	/**
+	 * Returns true if there are remaining element(s) in this buffer.
+	 * <p>
+	 * Or more precisely, returns <code>position &lt; limit</code>.
+	 * </p>
+	 * 
+	 * @return True if there are remaining element(s) in this buffer.
+	 */
+	public final boolean hasRemaining() {
+		return position < limit;
+	}
+
+	/**
+	 * Returns whether this buffer is readonly or not.
+	 * 
+	 * @return Whether this buffer is readonly or not.
+	 */
+	public abstract boolean isReadOnly();
+
+	/**
+	 * Returns the limit of this buffer.
+	 * 
+	 * @return The limit of this buffer.
+	 */
+	public final int limit() {
+		return limit;
+	}
+
+	/**
+	 * Sets the limit of this buffer.
+	 * <p>
+	 * If the current position in the buffer is in excess of
+	 * <code>newLimit</code> then, on returning from this call, it will have
+	 * been adjusted to be equivalent to <code>newLimit</code>. If the mark
+	 * is set and is greater than the new limit, then it is cleared.
+	 * </p>
+	 * 
+	 * @param newLimit
+	 *            The new limit, must be no less than zero and no greater than
+	 *            capacity
+	 * @return This buffer
+	 * @exception IllegalArgumentException
+	 *                If <code>newLimit</code> is invalid.
+	 */
+	public final Buffer limit(int newLimit) {
+		if (newLimit < 0 || newLimit > capacity) {
+			throw new IllegalArgumentException();
+		}
+
+		limit = newLimit;
+		if (position > newLimit) {
+			position = newLimit;
+		}
+		if ((mark != UNSET_MARK) && (mark > newLimit)) {
+			mark = UNSET_MARK;
+		}
+		return this;
+	}
+
+	/**
+	 * Mark the current position, so that the position may return to this point
+	 * later by calling <code>reset()</code>.
+	 * 
+	 * @return This buffer
+	 */
+	public final Buffer mark() {
+		mark = position;
+		return this;
+	}
+
+	/**
+	 * Returns the position of this buffer.
+	 * 
+	 * @return The value of this buffer's current position.
+	 */
+	public final int position() {
+		return position;
+	}
+
+	/**
+	 * Sets the position of this buffer.
+	 * <p>
+	 * If the mark is set and is greater than the new position, then it is
+	 * cleared.
+	 * </p>
+	 * 
+	 * @param newPosition
+	 *            The new position, must be no less than zero and no greater
+	 *            than limit
+	 * @return This buffer
+	 * @exception IllegalArgumentException
+	 *                If <code>newPosition</code> is invalid
+	 */
+	public final Buffer position(int newPosition) {
+		if (newPosition < 0 || newPosition > limit) {
+			throw new IllegalArgumentException();
+		}
+
+		position = newPosition;
+		if ((mark != UNSET_MARK) && (mark > position)) {
+			mark = UNSET_MARK;
+		}
+		return this;
+	}
+
+	/**
+	 * Returns the number of remaining elements in this buffer.
+	 * <p>
+	 * Or more precisely, returns <code>limit - position</code>.
+	 * </p>
+	 * 
+	 * @return The number of remaining elements in this buffer.
+	 */
+	public final int remaining() {
+		return limit - position;
+	}
+
+	/**
+	 * Reset the position of this buffer to the <code>mark</code>.
+	 * 
+	 * @return This buffer
+	 * @exception InvalidMarkException
+	 *                If the mark is not set
+	 */
+	public final Buffer reset() {
+		if (mark == UNSET_MARK) {
+			throw new InvalidMarkException();
+		}
+		position = mark;
+		return this;
+	}
+
+	/**
+	 * Rewinds this buffer.
+	 * <p>
+	 * The position is set to zero, and the mark is cleared.
+	 * </p>
+	 * <p>
+	 * The content of this buffer is not changed.
+	 * </p>
+	 * 
+	 * @return This buffer
+	 */
+	public final Buffer rewind() {
+		position = 0;
+		mark = UNSET_MARK;
+		return this;
+	}
+}
+

Propchange: incubator/harmony/enhanced/classlibadapter/trunk/modules/nio/src/main/java/java/nio/Buffer.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message