rem: Letter = tolower (Letter);
add: Letter = Letter + ('a' - 'A');
context: status_t ABSApp::TokenizeWhole (  BPositionIO *PositionIOPntr,  const char *OptionalFileName,  set<string> &WordSet,  char *ErrorMessage){  string                AccumulatedWord;  uint8                 Buffer [16 * 1024];  uint8                *BufferCurrentPntr = Buffer + 0;  uint8                *BufferEndPntr = Buffer + 0;  const char           *IOErrorString =                          "TokenizeWhole: Error %ld while reading \"%s\"";  size_t                Length;  int                   Letter = ' ';  char                  HexString [4];  int                   NextLetter = ' ';  int                   NextNextLetter = ' ';  /* Use a buffer since reading single characters from a BFile is so slow.  BufferCurrentPntr is the position of the next character to be read.  When it  reaches BufferEndPntr, it is time to fill the buffer again. */#define ReadChar(CharVar) \  { \    if (BufferCurrentPntr < BufferEndPntr) \      CharVar = *BufferCurrentPntr++; \    else /* Try to fill the buffer. */ \    { \      ssize_t AmountRead; \      AmountRead = PositionIOPntr->Read (Buffer, sizeof (Buffer)); \      if (AmountRead < 0) \      { \        sprintf (ErrorMessage, IOErrorString, AmountRead, OptionalFileName); \        return AmountRead; \      } \      else if (AmountRead == 0) \        CharVar = EOF; \      else \      { \        BufferEndPntr = Buffer + AmountRead; \        BufferCurrentPntr = Buffer + 0; \        CharVar = *BufferCurrentPntr++; \      } \    } \  }  /* Read all the words in the file and add them to our local set of words.  A  set is used since we don't care how many times a word occurs. */  while (true)  {    /* We read two letters ahead so that we can decode quoted printable    characters (an equals sign followed by two hex digits or a new line).  Note    that Letter can become EOF (-1) when end of file is reached. */    Letter = NextLetter;    NextLetter = NextNextLetter;    ReadChar (NextNextLetter);    /* Decode quoted printable codes first, so that the rest of the code just    sees an ordinary character.  Or even nothing, if it is the hidden line    break combination.  This may falsely corrupt stuff following an equals    sign, but usually won't. */    if (Letter == '=')    {      if ((NextLetter == '\r' && NextNextLetter == '\n') ||      (NextLetter == '\n' && NextNextLetter == '\r'))      {        /* Make the "=\r\n" pair disappear.  It's not even white space. */        ReadChar (NextLetter);        ReadChar (NextNextLetter);        continue;      }      if (NextLetter == '\n' || NextLetter == '\r')      {        /* Make the "=\n" pair disappear.  It's not even white space. */        NextLetter = NextNextLetter;        ReadChar (NextNextLetter);        continue;      }      if (NextNextLetter != EOF &&      isxdigit (NextLetter) && isxdigit (NextNextLetter))      {        /* Convert the hex code to a letter. */        HexString[0] = NextLetter;        HexString[1] = NextNextLetter;        HexString[2] = 0;        Letter = strtoul (HexString, NULL, 16 /* number system base */);        ReadChar (NextLetter);        ReadChar (NextNextLetter);      }    }    /* Convert to lower case to improve word matches.  Of course this loses a    bit of information, such as MONEY vs Money, an indicator of spam.  Well,    apparently that isn't all that useful a distinction, so do it. */    if (Letter >= 'A' && Letter < 'Z')      Letter = tolower (Letter);    /* See if it is a letter we treat as white space - all control characters    and all punctuation except for: apostrophe (so "it's" and possessive    versions of words get stored), dash (for hyphenated words), dollar sign    (for cash amounts), period (for IP addresses, we later remove trailing    (periods).  Note that codes above 127 are UTF-8 characters, which we    consider non-space. */    if (Letter < 0 /* EOF */ || (Letter < 128 && g_SpaceCharacters[Letter]))    {      /* That space finished off a word.  Remove trailing periods... */      while ((Length = AccumulatedWord.size()) > 0 &&      AccumulatedWord [Length-1] == '.')        AccumulatedWord.resize (Length - 1);      /* If there's anything left in the word, add it to the set.  Also ignore      words which are too big (it's probably some binary encoded data).  But      leave room for supercalifragilisticexpialidoceous.  According to one web      site, pneumonoultramicroscopicsilicovolcanoconiosis is the longest word      currently in English.  Note that some uuencoded data was seen with a 60      character line length. */      if (Length > 0 && Length <= g_MaxWordLength)        WordSet.insert (AccumulatedWord);      /* Empty out the string to get ready for the next word. */      AccumulatedWord.resize (0);    }    else /* Not a space-like character, add it to the word. */      AccumulatedWord.append (1 /* one copy of the char */, (char) Letter);    /* Stop at end of file or error.  Don't care which.  Exit here so that last    word got processed. */    if (Letter == EOF)      break;  }  return B_OK;}