gt:             if (bitPosition == 8) {
context: /*
   * Copyright (c) 2004, 2011, 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.
   *
   * THIS FILE WAS MODIFIED BY SUN MICROSYSTEMS, INC.
   */
  
  package com.sun.xml.internal.fastinfoset.algorithm;
  
  
  import java.io.EOFException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.nio.CharBuffer;
  import java.util.ArrayList;
  import java.util.List;
  
  import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmException;
  import com.sun.xml.internal.fastinfoset.CommonResourceBundle;
  
  
  /**
   *
   * An encoder for handling boolean values.  Suppports the builtin BOOLEAN encoder.
   *
   * @author Alan Hudson
   * @author Paul Sandoz
   *
   */
  public class BooleanEncodingAlgorithm extends BuiltInEncodingAlgorithm {
  
      /** Table for setting a particular bit of a byte */
      private static final int[] BIT_TABLE = {
          1 << 7,
          1 << 6,
          1 << 5,
          1 << 4,
          1 << 3,
          1 << 2,
          1 << 1,
          1 << 0};
  
      public int getPrimtiveLengthFromOctetLength(int octetLength) throws EncodingAlgorithmException {
          // Cannot determine the number of boolean values from just the octet length
          throw new UnsupportedOperationException();
      }
  
      public int getOctetLengthFromPrimitiveLength(int primitiveLength) {
          if (primitiveLength < 5) {
              return 1;
          } else {
              final int div = primitiveLength / 8;
              return (div == 0) ? 2 : 1 + div;
          }
      }
  
      public final Object decodeFromBytes(byte[] b, int start, int length) throws EncodingAlgorithmException {
          final int blength = getPrimtiveLengthFromOctetLength(length, b[start]);
          boolean[] data = new boolean[blength];
  
          decodeFromBytesToBooleanArray(data, 0, blength, b, start, length);
          return data;
      }
  
      public final Object decodeFromInputStream(InputStream s) throws IOException {
          final List booleanList = new ArrayList();
  
          int value = s.read();
          if (value == -1) {
              throw new EOFException();
          }
          final int unusedBits = (value >> 4) & 0xFF;
  
          int bitPosition = 4;
          int bitPositionEnd = 8;
          int valueNext = 0;
          do {
              valueNext = s.read();
              if (valueNext == -1) {
                  bitPositionEnd -= unusedBits;
              }
  
              while(bitPosition < bitPositionEnd) {
                  booleanList.add(
                          Boolean.valueOf((value & BIT_TABLE[bitPosition++]) > 0));
              }
  
              value = valueNext;
          } while (value != -1);
  
          return generateArrayFromList(booleanList);
      }
  
      public void encodeToOutputStream(Object data, OutputStream s) throws IOException {
          if (!(data instanceof boolean[])) {
              throw new IllegalArgumentException(CommonResourceBundle.getInstance().getString("message.dataNotBoolean"));
          }
  
          boolean array[] = (boolean[])data;
          final int alength = array.length;
  
          final int mod = (alength + 4) % 8;
          final int unusedBits = (mod == 0) ? 0 : 8 - mod;
  
          int bitPosition = 4;
          int value = unusedBits << 4;
          int astart = 0;
          while (astart < alength) {
              if (array[astart++]) {
                  value |= BIT_TABLE[bitPosition];
              }
  
              if (++bitPosition == 8) {
                  s.write(value);
                  bitPosition = value = 0;
              }
          }
  
          if (bitPosition != 8) {
              s.write(value);
          }
      }
  
      public final Object convertFromCharacters(char[] ch, int start, int length) {
          if (length == 0) {
              return new boolean[0];
          }
  
          final CharBuffer cb = CharBuffer.wrap(ch, start, length);
          final List booleanList = new ArrayList();
  
          matchWhiteSpaceDelimnatedWords(cb,
              new WordListener() {
                  public void word(int start, int end) {
                      if (cb.charAt(start) == 't') {
                          booleanList.add(Boolean.TRUE);
                      } else {
                          booleanList.add(Boolean.FALSE);
                      }
                  }
              }
          );
  
          return generateArrayFromList(booleanList);
      }
  
      public final void convertToCharacters(Object data, StringBuffer s) {
          if (data == null) {
              return;
          }
  
          final boolean[] value = (boolean[]) data;
          if (value.length == 0) {
              return;
          }
  
          // Insure conservately as all false
          s.ensureCapacity(value.length * 5);
  
          final int end = value.length - 1;
          for (int i = 0; i <= end; i++) {
              if (value[i]) {
                  s.append("true");
              } else {
                  s.append("false");
              }
              if (i != end) {
                  s.append(' ');
              }
          }
      }
  
      public int getPrimtiveLengthFromOctetLength(int octetLength, int firstOctet) throws EncodingAlgorithmException {
          final int unusedBits = (firstOctet >> 4) & 0xFF;
          if (octetLength == 1) {
             if (unusedBits > 3) {
                 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.unusedBits4"));
             }
             return 4 - unusedBits;
          } else {
             if (unusedBits > 7) {
                 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.unusedBits8"));
             }
             return octetLength * 8 - 4 - unusedBits;
          }
      }
  
      public final void decodeFromBytesToBooleanArray(boolean[] bdata, int bstart, int blength, byte[] b, int start, int length) {
          int value = b[start++] & 0xFF;
          int bitPosition = 4;
          final int bend = bstart + blength;
          while (bstart < bend) {
  