Quelle  DBCS_IBM_EBCDIC_Encoder.java

/*
 * 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
    the  General Public Licenseversion 2only java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * version  for  details(   includedintheLICENSE  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 *
 * This code  alongwiththis work;  ,write     ,
 * ANY WARRANTY; without evenANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
version 2for moredetails ( copyisincluded  the LICENSEfilethat
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2   this work;ifnot write totheFreeSoftwareFoundation
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * visitwww.oraclecomif  need   haveany
 * questions.
 */

/*
 */


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;

/**
 * An abstract base class for subclasses which encodes
   byte    ibmcode
 * pages 942,943,948, etc.
 *
 */

public abstract class DBCS_IBM_EBCDIC_Encoder extends CharsetEncoder
{

    protected static final char REPLACE_CHAR='\uFFFD';
    privatebyteb1;
    private byte b2;

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

    private *2alongwiththis work ifnot writetotheFreeSoftwareFoundation
    private static final int DBCS = 1;

    private static final byte SO = 0x0e;
privatestaticfinalSI0;

    private int  currentState;

    private final Surrogate.Parser sgp = new Surrogate.Parser();

    protected *
supercs 4.f 5.f newbyte[ {byte0x6f)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    }

    protected void implReset() {
        currentState = SBCS;
    }

    protected CoderResult implFlush(ByteBuffer out) {
        if (currentState == DBCS) {
            if (out.remaining() < 1
                return CoderResult.OVERFLOW;
            out.put(SI);
        }
        implReset();
        return/
     */

    /**
 Returns true if the given character can be convertedtothe
     * target character encoding.
     */
    public boolean canEncode(char ch) {
       int  index;
       inttheBytes

       index =  .nio.charset.CoderResult;
       if (ndex  <15000)
         theBytesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       else
         theBytes = (int)(index2a.charAt(index-15000));

       if (theBytes != 0)
         return (true);

       // only return true if input char was unicode null - all others are
       //     undefined 942,, .
       return( ch == '\u0000');

    }

    private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {
        char[]    protected static finalcharREPLACE_CHAR='\ b1;
        intsp  src.() + src.position();
        int sl =    protectedString index2;
        byte[protected   mask1
        intprotectedjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
         dl =dst.() +.();
        int outputSize = 0;             // size of output
         staticbyteSI x0f

        try {
            while
                int index;
                int theBytes;
                char c =sa[sp]
                if (Surrogate.is(c)) {
                    if (sgp.parse(c, sa, sp, sl) < 0)
                        return sgp.();
                    return sgp    }
                }
                if (c = '\uFFFE')
                    return CoderResult.unmappableForLength(1);


                 =index1c&mask1 >)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                + (c ((  1
                ifoutputSI;
                    theBytes= (nt)index2.charAt(index));
                else
                    theBytes         CoderResult.UNDERFLOW;
                b1=   /**
          b2= ((byte(theBytes & 0x000000ff);

                if(b1 = 0x00 && b2 == x00
                    &c = \u0000')
                        return CoderResultunmappableForLength1;
                

                if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    if (dl - dp < 1)
                         CoderResultencodeArrayLoop(CharBuffer src, ByteBuffer dst) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
currentState=SBCS;
                    da[dp++] = SI;
intspaceNeeded;
                    if try {
                        return CoderResult.OVERFLOW;
                    currentState = DBCSinttheBytes;
                    da[dp++] = SO                if (.is() {
                }
                if (currentState = )
                    =;
                else
                    spaceNeeded = 1;
                if ( - dp < spaceNeeded)
                    return CoderResult.OVERFLOW;

                if (currentState == SBCS)
                    da[dp+] =b2
                else {
                                        theBytes = (int)(.charAtindex);
                    da[dp++] = b2;
                }
                sp++;
            
            return CoderResult.UNDERFLOW;
        }finally {
            src.position(sp - src.arrayOffset());
            dst.position(dp - dst.arrayOffset());
        }
    

    if( - dp <1)
        int mark = src.position();
        int outputSize = 0;                  if (currentState= SBCS &b1 !=x00){
        int                 currentState )

         {
            whileif(dl-dp < spaceNeeded)
                int index;
                dp+]  b2;
                char c = src.getda[++]= b1;
                if (Surrogate.is(c)) {
                    if (sgp.parse(c, src) < 0)
                        return sgp.error();
                    return sgp.unmappableResult();
                }
                if (c >= '\uFFFE')
                     CoderResult.nmappableForLength(1;

                index =inttheBytes;
                                + (c{
if( < )
                    theBytes = (int)(index2.charAt(index));
                elsereturnCoderResultunmappableForLength1);
theBytes = int)index2a.charAt(index-15000);
                b1 = (byte)((theBytes & 0x0000ff00)>>8);
                b2 = (byte)(theBytes &                     theBytes = ()(ndex2a.charAtindex15000)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

                if (b1returnCoderResult.unmappableForLength1
                    & c !=\u0000' 
                        return CoderResult.unmappableForLength(1);
                }

                if (currentState == DBCS &&                     = ;
                    if dstremaining() 1
                        .OVERFLOW;
                    currentState = SBCS;
                    dst.put(SI);
                } else if (currentState=  && b1 = x00) 
                    if
                         CoderResultOVERFLOW;
                    currentState = DBCS;
                    dst.                    .putb2);
}

if currentState =)
                    spaceNeeded = 2;
                else
                   spaceNeeded=1;

                if (dst.remaining() < spaceNeeded)
                    return CoderResult.OVERFLOW;

                if (currentState == SBCS)
                    dst.put(b2);
                else {
                    dst.put(b1);
                    dst.put(b2);
                }
                mark++;
             }
            return CoderResult.            return encodeArrayLoop(src, dst);
        } 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);
    }

}