src/java.desktop/unix/classes/sun/awt/motif/X11GBK.java

*** 23,66 ****
   * questions.
   */
  
  package sun.awt.motif;
  
  import java.nio.charset.*;
! import sun.nio.cs.ext.*;
! import static sun.nio.cs.CharsetMapping.*;
  
  public class X11GBK extends Charset {
      public X11GBK () {
          super("X11GBK", null);
      }
      public CharsetEncoder newEncoder() {
          return new Encoder(this);
      }
      public CharsetDecoder newDecoder() {
!         return new GBK().newDecoder();
      }
  
      public boolean contains(Charset cs) {
          return cs instanceof X11GBK;
      }
  
!     private class Encoder extends DoubleByte.Encoder {
  
!         private DoubleByte.Encoder enc = (DoubleByte.Encoder)new GBK().newEncoder();
  
          Encoder(Charset cs) {
!             super(cs, (char[])null, (char[])null);
          }
  
          public boolean canEncode(char ch){
              if (ch < 0x80) return false;
              return enc.canEncode(ch);
          }
  
          public int encodeChar(char ch) {
!             if (ch < 0x80)
                  return UNMAPPABLE_ENCODING;
!             return enc.encodeChar(ch);
          }
      }
  }
--- 23,132 ----
   * questions.
   */
  
  package sun.awt.motif;
  
+ import java.nio.ByteBuffer;
+ import java.nio.CharBuffer;
  import java.nio.charset.*;
! import static sun.awt.motif.DoubleByte.*;
  
  public class X11GBK extends Charset {
+ 
+     private static Charset gbk = Charset.forName("GBK");
+ 
      public X11GBK () {
          super("X11GBK", null);
      }
      public CharsetEncoder newEncoder() {
          return new Encoder(this);
      }
      public CharsetDecoder newDecoder() {
!         return gbk.newDecoder();
      }
  
      public boolean contains(Charset cs) {
          return cs instanceof X11GBK;
      }
  
!     static class Encoder extends CharsetEncoder {
  
!         static final int MAX_SINGLEBYTE = 0xff;
!         static private CharsetEncoder enc = gbk.newEncoder();
  
          Encoder(Charset cs) {
!             super(cs, enc.averageBytesPerChar(), enc.maxBytesPerChar(),
!                   enc.replacement());
!             enc.onMalformedInput(CodingErrorAction.REPORT);
!             enc.onUnmappableCharacter(CodingErrorAction.REPORT);
          }
  
          public boolean canEncode(char ch){
              if (ch < 0x80) return false;
              return enc.canEncode(ch);
          }
  
          public int encodeChar(char ch) {
!             if (ch < 0x80) {
!                 return UNMAPPABLE_ENCODING;
!             }
!             char[] buf = new char[1];
!             buf[0] = ch;
!             ByteBuffer bb = null;
!             CharBuffer cb = CharBuffer.wrap(buf);
!             boolean mapped = false;
!             try {
!                 bb = enc.encode(cb);
!                 mapped = true;
!             } catch (CharacterCodingException cce) {
!             }
!             if (mapped && bb != null) {
!                 int ret = UNMAPPABLE_ENCODING;
!                 if (bb.remaining() == 1) {
!                    ret = bb.get() & 0xff;
!                 } else if (bb.remaining() > 1) {
!                    ret = ((bb.get() & 0xff) << 8) | (bb.get() & 0xff);
!                 }
!                 return ret;
!             } else {
                  return UNMAPPABLE_ENCODING;
!             }
!         }
! 
!         private SurrogateParser sgp;
!         protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {
!             int mark = src.position();
!             try {
!                 while (src.hasRemaining()) {
!                     char c = src.get();
!                     int bb = encodeChar(c);
!                     if (bb == UNMAPPABLE_ENCODING) {
!                         if (Character.isSurrogate(c)) {
!                             if (sgp == null) {
!                                 sgp = new SurrogateParser();
!                             }
!                             if (sgp.parse(c, src) < 0)
!                                 return sgp.error();
!                             return sgp.unmappableResult();
!                         }
!                         return CoderResult.unmappableForLength(1);
!                     }
!                     if (bb > MAX_SINGLEBYTE) {  // DoubleByte
!                         if (dst.remaining() < 2)
!                             return CoderResult.OVERFLOW;
!                         dst.put((byte)(bb >> 8));
!                         dst.put((byte)(bb));
!                     } else {
!                         if (dst.remaining() < 1)
!                         return CoderResult.OVERFLOW;
!                         dst.put((byte)bb);
!                     }
!                     mark++;
!                 }
!                 return CoderResult.UNDERFLOW;
!             } finally {
!                 src.position(mark);
!             }
! 
          }
      }
  }