/*
 * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 */

package sun.nio.cs.ext;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import sun.nio.cs.Surrogate;


public abstract class SimpleEUCEncoder
    extends CharsetEncoder
{

    protected short  index1[];
    protected String index2;
    protected String index2a;
    protected String index2b;
    protected String index2c;
    protected int    mask1;
    protected int    mask2;
    protected int    shift;

    private byte[] outputByte = new byte[4];
    private final Surrogate.Parser sgp = new Surrogate.Parser();

    protected SimpleEUCEncoder(Charset cs)
    {
        super(cs, 3.0f, 4.0f);
    }

    
Returns true if the given character can be converted to the target character encoding.
/** * Returns true if the given character can be converted to the * target character encoding. */
public boolean canEncode(char ch) { int index; String theChars; index = index1[((ch & mask1) >> shift)] + (ch & mask2); if (index < 7500) theChars = index2; else if (index < 15000) { index = index - 7500; theChars = index2a; } else if (index < 22500){ index = index - 15000; theChars = index2b; } else { index = index - 22500; theChars = index2c; } if (theChars.charAt(2*index) != '\u0000' || theChars.charAt(2*index + 1) != '\u0000') return (true); // only return true if input char was unicode null - all others are // undefined return( ch == '\u0000'); } private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) { char[] sa = src.array(); int sp = src.arrayOffset() + src.position(); int sl = src.arrayOffset() + src.limit(); assert (sp <= sl); sp = (sp <= sl ? sp : sl); byte[] da = dst.array(); int dp = dst.arrayOffset() + dst.position(); int dl = dst.arrayOffset() + dst.limit(); assert (dp <= dl); dp = (dp <= dl ? dp : dl); int index; int spaceNeeded; int i; try { while (sp < sl) { boolean allZeroes = true; char inputChar = sa[sp]; if (Character.isSurrogate(inputChar)) { if (sgp.parse(inputChar, sa, sp, sl) < 0) return sgp.error(); return sgp.unmappableResult(); } if (inputChar >= '\uFFFE') return CoderResult.unmappableForLength(1); String theChars; char aChar; // We have a valid character, get the bytes for it index = index1[((inputChar & mask1) >> shift)] + (inputChar & mask2); if (index < 7500) theChars = index2; else if (index < 15000) { index = index - 7500; theChars = index2a; } else if (index < 22500){ index = index - 15000; theChars = index2b; } else { index = index - 22500; theChars = index2c; } aChar = theChars.charAt(2*index); outputByte[0] = (byte)((aChar & 0xff00)>>8); outputByte[1] = (byte)(aChar & 0x00ff); aChar = theChars.charAt(2*index + 1); outputByte[2] = (byte)((aChar & 0xff00)>>8); outputByte[3] = (byte)(aChar & 0x00ff); for (i = 0; i < outputByte.length; i++) { if (outputByte[i] != 0x00) { allZeroes = false; break; } } if (allZeroes && inputChar != '\u0000') { return CoderResult.unmappableForLength(1); } int oindex = 0; for (spaceNeeded = outputByte.length; spaceNeeded > 1; spaceNeeded--){ if (outputByte[oindex++] != 0x00 ) break; } if (dp + spaceNeeded > dl) return CoderResult.OVERFLOW; for (i = outputByte.length - spaceNeeded; i < outputByte.length; i++) { da[dp++] = outputByte[i]; } sp++; } return CoderResult.UNDERFLOW; } finally { src.position(sp - src.arrayOffset()); dst.position(dp - dst.arrayOffset()); } } private CoderResult encodeBufferLoop(CharBuffer src, ByteBuffer dst) { int index; int spaceNeeded; int i; int mark = src.position(); try { while (src.hasRemaining()) { char inputChar = src.get(); boolean allZeroes = true; if (Character.isSurrogate(inputChar)) { if (sgp.parse(inputChar, src) < 0) return sgp.error(); return sgp.unmappableResult(); } if (inputChar >= '\uFFFE') return CoderResult.unmappableForLength(1); String theChars; char aChar; // We have a valid character, get the bytes for it index = index1[((inputChar & mask1) >> shift)] + (inputChar & mask2); if (index < 7500) theChars = index2; else if (index < 15000) { index = index - 7500; theChars = index2a; } else if (index < 22500){ index = index - 15000; theChars = index2b; } else { index = index - 22500; theChars = index2c; } aChar = theChars.charAt(2*index); outputByte[0] = (byte)((aChar & 0xff00)>>8); outputByte[1] = (byte)(aChar & 0x00ff); aChar = theChars.charAt(2*index + 1); outputByte[2] = (byte)((aChar & 0xff00)>>8); outputByte[3] = (byte)(aChar & 0x00ff); for (i = 0; i < outputByte.length; i++) { if (outputByte[i] != 0x00) { allZeroes = false; break; } } if (allZeroes && inputChar != '\u0000') { return CoderResult.unmappableForLength(1); } int oindex = 0; for (spaceNeeded = outputByte.length; spaceNeeded > 1; spaceNeeded--){ if (outputByte[oindex++] != 0x00 ) break; } if (dst.remaining() < spaceNeeded) return CoderResult.OVERFLOW; for (i = outputByte.length - spaceNeeded; i < outputByte.length; i++) { dst.put(outputByte[i]); } mark++; } return CoderResult.UNDERFLOW; } finally { src.position(mark); } } protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) { if (true && src.hasArray() && dst.hasArray()) return encodeArrayLoop(src, dst); else return encodeBufferLoop(src, dst); } public byte encode(char inputChar) { return (byte)index2.charAt(index1[(inputChar & mask1) >> shift] + (inputChar & mask2)); } }