D语言BetterC模式下高性能字符串替换算法实现

import core.stdc.string : strlen, memcmp, memcpy;

// 判断两个字符是否相等，根据 isCaseSensitive 参数决定是否区分大小写
boolean charEqual(char a, char b, boolean isCaseSensitive)
{
    if (isCaseSensitive)
    {
        return a == b;
    }
    else
    {
        return toLower(a) == toLower(b);
    }
}

// 在字符串 haystack 中查找第一次出现 needle 的位置，返回指向该位置的指针，如果找不到则返回 null
char* strstr(char* haystack, const char* needle, boolean isCaseSensitive)
{
    size_t haystackLen = strlen(haystack);
    size_t needleLen = strlen(needle);
    if (needleLen > haystackLen)
    {
        return null;
    }
    for (size_t i = 0; i <= haystackLen - needleLen; i++)
    {
        boolean found = true;
        for (size_t j = 0; j < needleLen; j++)
        {
            if (!charEqual(haystack[i + j], needle[j], isCaseSensitive))
            {
                found = false;
                break;
            }
        }
        if (found)
        {
            return haystack + i;
        }
    }
    return null;
}

// 将字符串 haystack 中的所有 needle 替换为 replace，并返回替换后的字符串，如果 haystack 中不包含 needle 则返回 haystack
char* replaceAll(char* haystack, const char* needle, const char* replace, boolean isCaseSensitive)
{
    size_t needleLen = strlen(needle);
    size_t replaceLen = strlen(replace);
    char* result = haystack;
    char* p = strstr(result, needle, isCaseSensitive);
    while (p != null)
    {
        char* oldResult = result;
        size_t oldResultLen = strlen(oldResult);
        size_t prefixLen = p - oldResult;
        size_t suffixLen = oldResultLen - prefixLen - needleLen;
        size_t newResultLen = prefixLen + replaceLen + suffixLen;
        char* newResult = cast(char*)malloc(newResultLen + 1);
        memcpy(newResult, oldResult, prefixLen);
        memcpy(newResult + prefixLen, replace, replaceLen);
        memcpy(newResult + prefixLen + replaceLen, p + needleLen, suffixLen);
        newResult[newResultLen] = '�';
        result = newResult;
        free(oldResult);
        p = strstr(result + prefixLen + replaceLen, needle, isCaseSensitive);
    }
    return result;
}

void main()
{
    char* allStr = 'hello world World';
    const char* searchStr = 'World';
    const char* replaceStr = 'china';
    boolean isCaseSensitive = false;

    char* result = replaceAll(allStr, searchStr, replaceStr, isCaseSensitive);
    writeln(result);
    free(result);
}