replaceString | C

					
//===============replaceString.c===============
#include "replaceString.h"

//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement){
        size_t fromLength = strlen(from);
        size_t replaceLength = strlen(replace);
        size_t replacementLength = strlen(replacement);
        size_t fromEndIt = 0;
        size_t toLength = 0;
        while(fromEndIt < fromLength){
                int replaceIt = 0;
                while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
                        ++replaceIt;
                }
                if(replaceIt == replaceLength){
                        //Update from buffer iterator positions
                        toLength += (fromEndIt + replacementLength);
                        from += (fromEndIt + replaceLength);
                        fromEndIt = 0;
                        continue;
                }
                ++fromEndIt;
        }
        toLength += fromEndIt;
        return toLength;
}
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement){
        size_t fromLength = strlen(from);
        size_t replaceLength = strlen(replace);
        size_t replacementLength = strlen(replacement);
        size_t fromEndIt = 0;
        while(fromEndIt < fromLength){
                int replaceIt = 0;
                while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
                        ++replaceIt;
                }
                if(replaceIt == replaceLength){
                        //Copy the string before the matched bit
                        memcpyToAndShiftPointers(to, from, fromEndIt);
                        //Copy the replacement too
                        memcpyToAndShiftPointer(to, replacement, replacementLength);
                        //Update from buffer iterator positions
                        from += replaceLength;
                        fromEndIt = 0;
                        continue;       //I don't want this thing to get incremented again
                }
                ++fromEndIt;
        }
        //Copy the rest of the unmatched string
        memcpyToAndShiftPointer(to, from, fromEndIt);
        to[0] = '\0';   //Should work
}
//===============replaceString.h===============
#ifndef REPLACE_STRING_H
#define REPLACE_STRING_H
#include <string.h>

#define memcpyToAndShiftPointer(to,from,n); memcpy((to),(from),(n)); (to) += (n);
#define memcpyToAndShiftPointers(to,from,n); memcpy((to),(from),(n)); (to) += (n); (from) += n;

//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement);
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement);
#endif
//===============replaceStringMain.c===============
#include <stdio.h>
#include <stdlib.h>
#include "replaceString.h"

#define BUFFER_SIZE (1<<21)     //About a mebibyte
//There could be matches between buffers, so make sure the buffer size you set it to is good enough for your application. Basically as big as your input.

//Replaces strings from sdtin, then outputs it to stdout
//./a.out [[replace], [replacement]]...
int main(int argc, char** argv){
        char* buffer1 = (char*) malloc(BUFFER_SIZE);
        char* buffer2 = (char*) malloc(BUFFER_SIZE);
        if(buffer1 == NULL || buffer2 == NULL){
                perror("You need a couple MBs of ram my boy");
                return 1;
        }
        while(!feof(stdin)){
                fread(buffer1, BUFFER_SIZE, 1, stdin);
                char* activeBuffer = buffer1;
                char* inactiveBuffer = buffer2;
                char* tmp;
                for(size_t i = 1; (i + 1) < argc; i += 2){
                        //puts(activeBuffer);
                        replaceString(inactiveBuffer, activeBuffer, argv[i], argv[i+1]);
                        //Swap buffers
                        tmp = activeBuffer;
                        activeBuffer = inactiveBuffer;
                        inactiveBuffer = tmp;
                }
                fputs(activeBuffer, stdout);
        }
        free(buffer1);
        free(buffer2);
        return 0;
}