void ShowPrompt()

in BusTools/I2cTestTool/main.cpp [192:335]
130 lines of code
32 McCabe index (conditional complexity)

void ShowPrompt (I2cDevice^ device)
{
    while (std::wcin) {
        std::wcout << L"> ";

        std::wstring line;
        if (!std::getline(std::wcin, line)) {
            return;
        }
        std::wistringstream linestream(line);

        std::wstring command;
        linestream >> command;
        if ((command == L"q") || (command == L"quit")) {
            return;
        } else if ((command == L"h") || (command == L"help")) {
            std::wcout << Help;
        } else if (command == L"write") {
            std::vector<BYTE> writeBuf;
            if (!(linestream >> writeBuf)) {
                std::wcout << L"Usage: write { 55 a0 ... ff }\n";
                continue;
            }

            I2cTransferResult result = device->WritePartial(
                ArrayReference<BYTE>(
                    writeBuf.data(),
                    static_cast<unsigned int>(writeBuf.size())));

            switch (result.Status) {
            case I2cTransferStatus::FullTransfer:
                break;
            case I2cTransferStatus::PartialTransfer:
                std::wcout << L"Partial Transfer. Transferred " <<
                    result.BytesTransferred << L" bytes\n";
                break;
            case I2cTransferStatus::SlaveAddressNotAcknowledged:
                std::wcout << L"Slave address was not acknowledged\n";
                break;
            case I2cTransferStatus::ClockStretchTimeout:
                std::wcout << L"A clock stretch timeout occurred\n";
                break;
            case I2cTransferStatus::UnknownError:
                std::wcout << L"The transfer failed for an unknown reason\n";
                break;
            default:
                throw wexception(L"Invalid transfer status value");
            }
        } else if (command == L"read") {
            // expecting a single int, number of bytes to read
            unsigned int bytesToRead;
            if (!(linestream >> std::dec >> bytesToRead)) {
                std::wcout << L"Expecting integer. e.g: read 4\n";
                continue;
            }

            auto readBuf = ref new Platform::Array<BYTE>(bytesToRead);
            I2cTransferResult result = device->ReadPartial(readBuf);

            switch (result.Status) {
            case I2cTransferStatus::FullTransfer:
                std::wcout << readBuf << L"\n";
                break;
            case I2cTransferStatus::PartialTransfer:
                std::wcout << L"Partial Transfer. Transferred " <<
                    result.BytesTransferred << L" bytes\n";
                std::wcout << readBuf << L"\n";
                break;
            case I2cTransferStatus::SlaveAddressNotAcknowledged:
                std::wcout << L"Slave address was not acknowledged\n";
                break;
            case I2cTransferStatus::ClockStretchTimeout:
                std::wcout << L"A clock stretch timeout occurred\n";
                break;
            case I2cTransferStatus::UnknownError:
                std::wcout << L"The transfer failed for an unknown reason\n";
                break;
            default:
                throw wexception(L"Invalid transfer status value");
            }
        } else if (command == L"writeread") {
            // get a sequence of bytes, e.g.
            //   write 0 1 2 3 4 aa bb cc dd
            std::vector<BYTE> writeBuf;
            if (!(linestream >> writeBuf)) {
                std::wcout << L"Usage: writeread { 55 a0 ... ff } 4\n";
                continue;
            }

            unsigned int bytesToRead;
            if (!(linestream >> std::dec >> bytesToRead)) {
                std::wcout << L"Syntax error: expecting integer\n";
                std::wcout << L"Usage: writeread { 55 a0 ... ff } 4\n";
                continue;
            }
            auto readBuf = ref new Array<BYTE>(bytesToRead);

            I2cTransferResult result = device->WriteReadPartial(
                ArrayReference<BYTE>(
                    writeBuf.data(),
                    static_cast<unsigned int>(writeBuf.size())),
                readBuf);

            switch (result.Status) {
            case I2cTransferStatus::FullTransfer:
                std::wcout << readBuf << L"\n";
                break;
            case I2cTransferStatus::PartialTransfer:
            {
                std::wcout << L"Partial Transfer. Transferred " <<
                    result.BytesTransferred << L" bytes\n";
                int bytesRead = result.BytesTransferred - int(writeBuf.size());
                if (bytesRead > 0) {
                    std::wcout << readBuf << L"\n";
                }
                break;
            }
            case I2cTransferStatus::SlaveAddressNotAcknowledged:
                std::wcout << L"Slave address was not acknowledged\n";
                break;
            case I2cTransferStatus::ClockStretchTimeout:
                std::wcout << L"A clock stretch timeout occurred\n";
                break;
            case I2cTransferStatus::UnknownError:
                std::wcout << L"The transfer failed for an unknown reason\n";
                break;
            default:
                throw wexception(L"Invalid transfer status value");
            }
        } else if (command == L"info") {
            int slaveAddress = device->ConnectionSettings->SlaveAddress;
            I2cBusSpeed busSpeed = device->ConnectionSettings->BusSpeed;

            std::wcout << L"       DeviceId: " << device->DeviceId->Data() << "\n";
            std::wcout << L"  Slave address: 0x" << std::hex << slaveAddress << L"\n";
            std::wcout << L"      Bus Speed: " << busSpeed << L"\n";
        } else if (command.empty()) {
            // ignore
        } else {
            std::wcout << L"Unrecognized command: " << command <<
                L". Type 'help' for command usage.\n";
        }
    }
}