Быстрая реализация поиска строк в csv/txt(ANSI) файлах (WinAPI + С++)

extern "C" __declspec(dllexport) LPXLOPER12  WINAPI FindRowsInCSVansi(wchar_t *  file, char* findStr, bool multiLine, int fileFlagNoBuffering)
{
    LPXLOPER12 OperOut = TempErr12(xlerrValue);
       
    const DWORD  nNumberOfBytesToRead = 16777216;//67108864;//33554432; //16777216;//8388608;//читаем в буфер байты
    size_t findStrLen = strlen(findStr);
    if (findStrLen >= nNumberOfBytesToRead) { return OperOut; };
 
    // создаем события с автоматическим сбросом
    HANDLE hEndRead = CreateEvent(NULL, FALSE, FALSE, NULL);// дескриптор события
    if (hEndRead == NULL){  return OperOut; }
 
    // открываем файл для чтения
    HANDLE hFile = CreateFile(  // дескриптор файла
        file,   // имя файла
        GENERIC_READ,          // чтение из файла
        FILE_SHARE_READ,       // совместный доступ к файлу
        NULL,                  // защиты нет
        OPEN_EXISTING,         // открываем существующий файл
        FILE_FLAG_OVERLAPPED | (fileFlagNoBuffering != 0 ? FILE_FLAG_NO_BUFFERING : FILE_FLAG_RANDOM_ACCESS),// асинхронный ввод//отключаем системный буфер
        NULL                   // шаблона нет
    );
    // проверяем на успешное открытие
    if (hFile == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hEndRead);
        return OperOut;
    }
 
    char* notAlignBuf = new char[nNumberOfBytesToRead * 2 + 4096 + 1]; //буфер
    char* buf = notAlignBuf + nNumberOfBytesToRead;; //буфер
    if (size_t(buf) % 4096) { buf += 4096 - (size_t(buf) % 4096); }//адрес принимающего буфера тоже должен быть выровнен по размеру сектора/страницы 
 
    char* notAlignBufWork = new char[nNumberOfBytesToRead * 2 + 4096 + 1]; //буфер Рабочий
    char* bufWork = notAlignBufWork + nNumberOfBytesToRead; //буфер
    if (size_t(bufWork) % 4096) { bufWork += 4096 - (size_t(bufWork) % 4096); }//адрес рабочего буфера тоже выровнял по размеру сектора/страницы  
 
    buf[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
    bufWork[0] = '\0';//добавим нуль-терминатор
    bufWork[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
 
    DWORD dwBytesReadWork = 0;
    DWORD findStatus = 0; //статус поиска
    bool errHandleEOF = false; //метка конца файла
    char* find;// указатель для поиска
    char* strStart;
    char* strEnd;
    char* bufWorkNew = bufWork;//буфер с учетом полной строки
    size_t strStartLen = 0;
    size_t strCount = 1; //счетчик строк
    std::string strOut; //итоговая строка
 
    _ULARGE_INTEGER ui; //Представляет 64-разрядное целое число без знака обединяя два 32-х разрядных
    ui.QuadPart = 0;
 
    OVERLAPPED  ovl;   // структура управления асинхронным доступом к файлу// инициализируем структуру OVERLAPPED
    ovl.Offset = 0;         // младшая часть смещения равна 0
    ovl.OffsetHigh = 0;      // старшая часть смещения равна 0
    ovl.hEvent = hEndRead;   // событие для оповещения завершения чтения
 
    // читаем данные из файла
    for (;;)
    {
        DWORD  dwBytesRead;
        DWORD  dwError;
        find = buf; //буфер
        // читаем одну запись
        if (!ReadFile(
            hFile,           // дескриптор файла
            buf,             // адрес буфера, куда читаем данные
            nNumberOfBytesToRead,// количество читаемых байтов
            &dwBytesRead,    // количество прочитанных байтов
            &ovl             // чтение асинхронное
        ))
        {
            switch (dwError = GetLastError())// решаем что делать с кодом ошибки
            {
                //эти ошибки смотрм после завершения асинхронной операции чтения, для возможности обработать рабочий буфер
            case ERROR_IO_PENDING: { break; }        // асинхронный ввод-вывод все еще происходит // сделаем кое-что пока он идет 
            case ERROR_HANDLE_EOF: { errHandleEOF = true;   break; } // мы достигли конца файла читалкой ReadFile
            default: {goto return1; }// другие ошибки
            }
        }
 
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
        bufWork[dwBytesReadWork] = '\0';//добавим нуль-терминатор
    goNextFind:
        if (findStatus == 0)//goFind
        {
            find = strstr(bufWorkNew, findStr);
            if (find != NULL) //если нужная подстрока найдена
            {
                for (strStart = find; strStart >= bufWorkNew; strStart--)
                {
                    if (*strStart == '\n') { break; } //если нашли начало строки
                }
                strStart++; //не учитываем '\n'
 
                strEnd = strchr(find, '\n'); //ищем конец строки
                if (strEnd != NULL) //если нашли конец строки
                {
                    strOut = strOut + std::string(strStart, strEnd - strStart + 1);
                    if (!multiLine)
                    {
                        goto return0;
                    }
                    else//поиск в следующей строке начинаем с конца предыдущей
                    {
                        bufWorkNew = strEnd++;
                        findStatus = 0;
                        goto goNextFind;
                    }
                }
                else//если конец строки в следующем буфере или конец файла
                {
                    strOut = strOut + std::string(strStart);
                    findStatus = 1;
                }
            } //если нужная подстрока найдена
        }
        else if (findStatus == 1)//goBuf
        {
            strEnd = strchr(bufWork, '\n');
            if (strEnd != NULL) //если нашли конец строки
            {
                strOut = strOut + std::string(bufWork, strEnd - bufWork + 1);
                findStatus = 0;
                if (!multiLine)
                {
                    goto return0;
                }
                else//поиск в следующей строке начинаем с конца предыдущей
                {
                    bufWorkNew = strEnd++;
                    findStatus = 0;
                    goto goNextFind;
                }
            }
            else//если конец строки в следующем буфере или конец файла
            {
                strOut = strOut + std::string(bufWork);
            }
        }
 
        //блок дозагрузки рабочего буфера межбуферной строкой
        char* bufWorkEnd = bufWork + dwBytesReadWork; //конец буфера
        for (strStart = bufWorkEnd; strStart >= bufWork; strStart--) { if (*strStart == '\n') { break; } } //если нашли начало строки
        if (strStart < bufWork && ui.QuadPart >= nNumberOfBytesToRead) { goto return1; }; //если строка больше буфера (не найден разделитель), кроме первого буфера
        strStartLen = (bufWorkEnd - ++strStart); //размер буфера, который добавляем к рабочему
        //пишем начало строки в новый буфер
        bufWorkNew = buf - strStartLen;//bufWorkNew = bufWork - strStartLen;
        memcpy(bufWorkNew, strStart, strStartLen);
        //
 
        if (errHandleEOF) { goto return0; }
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
 
        // ждем, пока завершится асинхронная операция чтения
        WaitForSingleObject(hEndRead, INFINITE);
 
        // проверим результат работы асинхронного чтения // если возникла проблема ... 
        if (!GetOverlappedResult(hFile, &ovl, &dwBytesRead, FALSE))
        {
            switch (dwError = GetLastError())// решаем что делать с кодом ошибки
            {
            case ERROR_HANDLE_EOF: { goto return0; break; }//если конец файла. но мы должны вернутся найти начало строки.
            // мы достигли конца файла в ходе асинхронной операции
            default: {goto return1; }// другие ошибки
            }// конец процедуры switch (dwError = GetLastError())
        }
 
        //меняем буфер
        char* bufTmp = bufWork;
        bufWork = buf;
        buf = bufTmp;
        //
 
        // увеличиваем смещение в файле
        dwBytesReadWork = dwBytesRead;//кол-во считанных байт
        ui.QuadPart += nNumberOfBytesToRead; //добавляем смещение к указателю на файл
        ovl.Offset = ui.LowPart;// вносим смещение в младшее слово
        ovl.OffsetHigh = ui.HighPart;// вносим смещение в старшеее слово
    }
 
return0:
    // закрываем дескрипторы, освобождаем память
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
 
    OperOut->xltype = xltypeStr | xlbitDLLFree;
    if (strOut.length() > 32767)
    {
        OperOut->val.str = new XCHAR[24 + 2]; //+1 под размер + 1 под нуль-терминатор
        wcscpy(OperOut->val.str + 1, L"Overflow. Max char 32767\0");
        OperOut->val.str[0] = 24;
    }
    else
    {
        OperOut->val.str = new XCHAR[strOut.length() + 2]; //+1 под размер + 1 под нуль-терминатор
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, strOut.c_str(), -1, OperOut->val.str + 1, strOut.length() + 1);
        OperOut->val.str[0] = strOut.length();
    }
    return OperOut;
 
return1:
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
    return OperOut;
}