docs: public final int peekNullTypeSymbol() throws IOException
      {
          // the '.' has to follow the 'null' immediately
          int c = read_char();
          if (c != '.') {
              unread_char(c);
              return IonTokenConstsX.KEYWORD_none;
          }
  
          // we have a dot, start reading through the following non-whitespace
          // and we'll collect it so that we can unread it in the event
          // we don't actually see a type name
          int[] read_ahead = new int[IonTokenConstsX.TN_MAX_NAME_LENGTH + 1];
          int read_count = 0;
          int possible_names = IonTokenConstsX.KW_ALL_BITS;
  
          while (read_count < IonTokenConstsX.TN_MAX_NAME_LENGTH + 1) {
              c = read_char();
              read_ahead[read_count++] = c;
              int letter_idx = IonTokenConstsX.typeNameLetterIdx(c);
              if (letter_idx < 1) {
                  if (IonTokenConstsX.isValidTerminatingCharForInf(c)) {
                      // it's not a letter we care about but it is
                      // a valid end of const, so maybe we have a keyword now
                      // we always exit the loop here since we look
                      // too far so any letter is invalid at pos 10
                      break;
                  }
                  return peekNullTypeSymbolUndo(read_ahead, read_count);
              }
              int mask = IonTokenConstsX.typeNamePossibilityMask(read_count - 1, letter_idx);
              possible_names &= mask;
              if (possible_names == 0) {
                  // in this case it can't be a valid keyword since
                  // it has identifier chars (letters) at 1 past the
                  // last possible end (at least)
                  return peekNullTypeSymbolUndo(read_ahead, read_count);
              }
          }
          // now lets get the keyword value from our bit mask
          // at this point we can fail since we may have hit
          // a valid terminator before we're done with all key
          // words.  We even have to check the length.
          // for example "in)" matches both letters to the
          // typename int and terminates validly - but isn't
          // long enough, but with length we have enough to be sure
          // with the actual type names we're using in 1.0
          int kw = IonTokenConstsX.typeNameKeyWordFromMask(possible_names, read_count-1);
          if (kw == IonTokenConstsX.KEYWORD_unrecognized) {
              peekNullTypeSymbolUndo(read_ahead, read_count);
          }
          else {
              // since we're accepting the rest we aren't unreading anything
              // else - but we still have to unread the character that stopped us
              unread_char(c);
          }
          return kw;
      }