--- /home/cpdev/src/classpath/gnu/java/nio/charset/UTF_16Encoder.java	2005-07-02 21:03:08.000000000 +0000
+++ gnu/java/nio/charset/UTF_16Encoder.java	2005-06-30 05:34:10.000000000 +0000
@@ -38,7 +38,6 @@
 package gnu.java.nio.charset;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.nio.CharBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
@@ -55,21 +54,20 @@
   static final int BIG_ENDIAN = 0;
   static final int LITTLE_ENDIAN = 1;
 
-  private static final char BYTE_ORDER_MARK = 0xFEFF;
+  private static final char BYTE_ORDER_MARK = '\uFEFF';
 
-  private final ByteOrder byteOrder;
+  private final int byteOrder;
   private final boolean useByteOrderMark;
   private boolean needsByteOrderMark;
 
   UTF_16Encoder (Charset cs, int byteOrder, boolean useByteOrderMark)
   {
     super (cs, 2.0f,
-           useByteOrderMark ? 4.0f : 2.0f,
+           useByteOrderMark ? 2.0f : 4.0f,
            byteOrder == BIG_ENDIAN
              ? new byte[] { (byte) 0xFF, (byte) 0xFD }
              : new byte[] { (byte) 0xFD, (byte) 0xFF });
-    this.byteOrder = (byteOrder == BIG_ENDIAN) ? 
-	ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
+    this.byteOrder = byteOrder;
     this.useByteOrderMark = useByteOrderMark;
     this.needsByteOrderMark = useByteOrderMark;
   }
@@ -78,17 +76,11 @@
   {
     // TODO: Optimize this in the case in.hasArray() / out.hasArray()
 
-    ByteOrder originalBO = out.order();
-    out.order(byteOrder);
-
     if (needsByteOrderMark)
       {
         if (out.remaining () < 2)
-	    {
-		out.order(originalBO);
-		return CoderResult.OVERFLOW;
-	    }
-        out.putChar (BYTE_ORDER_MARK);	
+          return CoderResult.OVERFLOW;
+        put (out, BYTE_ORDER_MARK);
         needsByteOrderMark = false;
       }
 
@@ -98,6 +90,7 @@
         while (in.hasRemaining ())
           {
             char c = in.get ();
+
             if (0xD800 <= c && c <= 0xDFFF)
               {
                 // c is a surrogate
@@ -111,22 +104,19 @@
                 // make sure d is a low surrogate
                 if (d < 0xDC00 || d > 0xDFFF)
                   return CoderResult.malformedForLength (1);
-                out.putChar (c);
-                out.putChar (d);
+                put (out, c);
+                put (out, d);
                 inPos += 2;
               }
             else
               {
                 if (out.remaining () < 2)
-		  {
-		    out.order(originalBO);
-		    return CoderResult.OVERFLOW;
-		  }
-                out.putChar (c);
+                  return CoderResult.OVERFLOW;
+                put (out, c);
                 inPos++;
               }
           }
-	out.order(originalBO);
+
         return CoderResult.UNDERFLOW;
       }
     finally
@@ -135,6 +125,24 @@
       }
   }
 
+  /**
+   * Writes <code>c</code> to <code>out</code> in the byte order
+   * specified by <code>byteOrder</code>.
+   **/
+  private void put (ByteBuffer out, char c)
+  {
+    if (byteOrder == BIG_ENDIAN)
+      {
+        out.put ((byte) (c >> 8));
+        out.put ((byte) (c & 0xFF));
+      }
+    else
+      {
+        out.put ((byte) (c & 0xFF));
+        out.put ((byte) (c >> 8));
+      }
+  }
+
   protected void implReset ()
   {
     needsByteOrderMark = useByteOrderMark;