Extract Text from PDF in C# (100% .NET)

if (CheckToken(new string[] {"'", "T*", "\""}, previousCharacters))
{
         resultString += "\n";
}

if ((recent[_numberOfCharsToKeep - 3] == token[0]) &&
   (recent[_numberOfCharsToKeep - 2] == token[1]) &&
...

private bool CheckToken(string[] tokens, char[] recent)
        {
            foreach(string token in tokens)
            {
                if (token.Length > 1)
                {
                    if ((recent[_numberOfCharsToKeep - 3] == token[0]) &&
                        (recent[_numberOfCharsToKeep - 2] == token[1]) &&
                        ((recent[_numberOfCharsToKeep - 1] == ' ') ||
                        (recent[_numberOfCharsToKeep - 1] == 0x0d) ||
                        (recent[_numberOfCharsToKeep - 1] == 0x0a)) &&
                        ((recent[_numberOfCharsToKeep - 4] == ' ') ||
                        (recent[_numberOfCharsToKeep - 4] == 0x0d) ||
                        (recent[_numberOfCharsToKeep - 4] == 0x0a))
                        )
                    {
                        return true;
                    }
                }
                else
                {
                    if ((recent[_numberOfCharsToKeep - 2] == token[0]) &&
                        ((recent[_numberOfCharsToKeep - 1] == ' ') ||
                        (recent[_numberOfCharsToKeep - 1] == 0x0d) ||
                        (recent[_numberOfCharsToKeep - 1] == 0x0a)) &&
                        ((recent[_numberOfCharsToKeep - 4] == ' ') ||
                        (recent[_numberOfCharsToKeep - 4] == 0x0d) ||
                        (recent[_numberOfCharsToKeep - 4] == 0x0a))
                        )
                    {
                        return true;
                    }
                }
            }
            return false;
        }

#region GetCharFromHex
/// <summary>
/// convert 4 (or less) hex digits to unicode character.
/// Hex digits are stored at the end of previousCharacters.
/// </summary>
private char GetCharFromHex(char[] previousCharacters, int hexDigits)
{
    short code = 0;
    code = Convert.ToInt16(new string(previousCharacters, previousCharacters.Length - hexDigits, hexDigits), 16);
    // if there are less digits than 4, we add zeros to the right (e.g. 'ab' -> 'ab00'). This is done according to PDF specification.
    while (hexDigits < 4)
    {
        code <<= 4;
        hexDigits++;
    }
    return (char)code;
}
#endregion
 
#region ExtractTextFromPDFBytes
/// <summary>
/// This method processes an uncompressed Adobe (text) object 
/// and extracts text.
/// </summary>
/// <param name="input">uncompressed</param>
/// <returns></returns>
public string ExtractTextFromPDFBytes(byte[] input)
{
    if (input == null || input.Length == 0) return "";
 
    StringBuilder resultString = new StringBuilder(4096);
 
    // Flag showing if we are we currently inside a text object
    bool inTextObject = false;
 
    // Flag showing if the next character is literal 
    // e.g. '\\' to get a '\' character or '\(' to get '('
    bool nextLiteral = false;
 
    // () Bracket nesting level. Text appears inside ()
    int bracketDepth = 0;
    // is in hex string: <1234>
    bool inHexString = false;
    // number of hex digits read while in hex string.
    int hexDigits = 0;
 
    // Keep previous chars to get extract numbers etc.:
    char[] previousCharacters = new char[_numberOfCharsToKeep];
    for (int j = 0; j < _numberOfCharsToKeep; j++) previousCharacters[j] = ' ';
 
    for (int i = 0; i < input.Length; i++)
    {
        char c = (char)input[i];
 
        if (inTextObject)
        {
            // Position the text
            if (bracketDepth == 0 && !inHexString)
            {
                if (CheckToken(new string[] { "TD", "Td" }, previousCharacters))
                    resultString.Append("\n\r");
                else
                {
                    if (CheckToken(new string[] { "'", "T*", "\"" /*"*/ /*fix code highlighting on codeproject*/ }, previousCharacters))
                        resultString.Append("\n");
                    else
                    {
                        if (CheckToken(new string[] { "Tj" }, previousCharacters))
                            resultString.Append(' ');
                    }
                }
            }
 
            // End of a text object, also go to a new line.
            if (bracketDepth == 0 && !inHexString &&
                CheckToken(new string[] { "ET" }, previousCharacters))
            {
 
                inTextObject = false;
                if (resultString.Length > 0 && resultString[resultString.Length - 1] != ' ')
                    resultString.Append(' ');
            }
            else
            {
                // Start outputting text
                if ((c == '(') && (bracketDepth == 0) && (!nextLiteral))
                {
                    bracketDepth = 1;
                }
                else
                {
                    // Stop outputting text
                    if ((c == ')') && (bracketDepth == 1) && (!nextLiteral))
                    {
                        bracketDepth = 0;
                    }
                    else
                    {
                        if (c == '<' && !inHexString && bracketDepth == 0)
                        { // Start of hex string
                            inHexString = true;
                            hexDigits = 0;
                        }
                        else
                        {
                            if ((c == '<' || c == '>') && inHexString) // end of hex string e.g. <1234>
                                // or this is not hex string but dictionary e.g. <<dict>>
                            {
                                if (hexDigits > 0) // convert last char
                                    resultString.Append(GetCharFromHex(previousCharacters, hexDigits));
                                inHexString = false;
                            }
                            else
                                // Just a normal text character:
                                if (bracketDepth == 1)
                                {
                                    if (c == '\\' && !nextLiteral)
                                    { // start of escaped character
                                        nextLiteral = true;
                                    }
                                    else
                                    {
                                        if (nextLiteral && c >= '0' && c <= '9')
                                        { // character is encoded in octal code
                                            char[] octalCode = {(char)input[i], (char)input[++i], (char)input[++i]};
                                            c = (char)Convert.ToInt32(new string(octalCode), 8);
                                        }
                                        
                                        if (((c >= ' ') && (c <= '~')) ||
                                            ((c >= 128) && (c < 255)))
                                        {
                                            resultString.Append(c);
                                        }
 
                                        nextLiteral = false;
                                    }
                                }
                                else
                                    if (inHexString)
                                    {
                                        if (hexDigits == 4)
                                        { // ready to extract next unicode character (4 hex digits)
                                            resultString.Append(GetCharFromHex(previousCharacters, hexDigits));
                                            hexDigits = 0;
                                        }
                                        hexDigits++; // new hex digit c is not added to previousCharacters yet, but it will be added below,
                                            // so I increment hexDigits after the check for 4.
                                    }
                        }
                    }
                }
            }
        }
 
        // Store the recent characters for 
        // when we have to go back for a checking
        for (int j = 0; j < _numberOfCharsToKeep - 1; j++)
        {
            previousCharacters[j] = previousCharacters[j + 1];
        }
        previousCharacters[_numberOfCharsToKeep - 1] = c;
 
        // Start of a text object
        if (!inTextObject && CheckToken(new string[] { "BT" }, previousCharacters))
        {
            inTextObject = true;
        }
    }
    return resultString.ToString();
}
#endregion