libsheepy

search_and_replace_strings_in_files.c (6079B)

---

 //#!/usr/bin/tcc -run
 // search and replace
 // input:
 //   file.txt
 //   replace_configuration.txt
 // the files to process are listed in file.txt in current directory.
 // Use # to comment lines in files.txt.
 // replace_configuration.txt holds the strings to search and replace in the files listed in file.txt
 //
 // replace_configuration.txt format:
 //  - line 1: separetor in line 2 and 3
 //  - line 2: strings to search separeted with the characters in line 1
 //  - line 3: replace strings separeted with the characters in line 1
 
 #include "../release/libsheepy.h"
 #include "../release/libsheepy.c"
 #include "pcre.h"
 
 #define internal static
 
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
 
 void replace();
 void replaceWithPcre(char **l, pcre *reCompiled, pcre_extra *pcreExtra, char *replaceWith);
 #ifndef unitTest
 #endif
 int MAIN(int ARGC, char** ARGV);
 
 int argc; char **argv;
 
 void replace() {
     char **replace_configuration = NULL;
     char **search_what = NULL;
     char **replace_with = NULL;
     char **config = NULL;
 
     // Steps
     // load config
     // create string regex
     // compile regexes
     // optimize the regex
     // create regex for each search string
     // for each file in files.txt, search and replace
 
     printf("\nLoading config...\n");
     printf("\n");
 
     // load config
     replace_configuration = readText("replace_configuration.txt");
 
     exitFailure(replace_configuration);
 
     search_what  = split(replace_configuration[1], replace_configuration[0]);
     replace_with = split(replace_configuration[2], replace_configuration[0]);
 
     if (!search_what || !replace_with) {
       printf("wrong replace_configuration.txt");
       printf("\n");
       XFAILURE;
     }
 
     // create string regex
     char **strRegex = NULL;
     enumerateCharP(search_what, e, i) {
         printf("Replace: ");
         printf("\n");
         printf("%s\n", *e);
         printf("With:");
         printf("\n");
         printf("%s\n", replace_with[i]);
         char *reg = catS("\\b", *e, "\\b");
         pErrorNULL(iListPushS(&strRegex, reg));
     }
 
     //listPrintS(strRegex);
 
     // compile regexes
     // optimize the regex
     size_t nSearch = listLengthS(search_what);
     pcre **reCompiled = malloc((nSearch+1) * sizeof(pcre *));
     reCompiled[nSearch] = NULL;
     pcre_extra **pcreExtra = malloc((nSearch+1) * sizeof(pcre_extra *));
     pcreExtra[nSearch] = NULL;
 
     const char *pcreErrorStr;
     int pcreErrorOffset;
 
     // create regex for each search string
     enumerateCharP(strRegex, e, j) {
       reCompiled[j] = pcre_compile(*e, 0, &pcreErrorStr, &pcreErrorOffset, NULL);
       if (!reCompiled[j]) {
         printf("ERROR: Could not study >%s<: %s", *e, pcreErrorStr);
         printf("\n");
         XFAILURE;
       }
 
       pcreExtra[j] = pcre_study(reCompiled[j], 0, &pcreErrorStr);
       if (!pcreExtra) {
         printf("ERROR: Could not study >%s<: %s", *e, pcreErrorStr);
         printf("\n");
         XFAILURE;
     }
       }
 
 
     printf("\n\nProcess files...\n");
     printf("\n");
 
     config = readText("files.txt");
     exitFailure(config);
 
     // for each file in files.txt, search and replace
     forEachCharP(config, f) {
         if (!isBlankS(*f)) {
             if (*f[0] != '#') {
                 pErrorNULL(iTrimS(f));
                 char **src = readText(*f);
                 if (!src) {
                     printf("Cant read file %s", *f);
                     printf("\n");
                     continue;
                 }
 
                 // scan lines
                 forEachCharP(src, l) {
                     enumerateCharP(search_what, a, i) {
                         //iReplaceS_max(l, *a, replace_with[i]);
                         replaceWithPcre(l, reCompiled[i], pcreExtra[i], replace_with[i]);
                 }
                     }
 
                 bool status = writeText(*f, src);
                 if (status) {
                     printf("CHANGED:      %s", *f);
                     printf("\n");
                 }
                 else {
                     printf("DIDNT CHANGE: %s", *f);
                     printf("\n");
     }
         }
             }
                 }
 
     listFreeManyS(replace_configuration, search_what, replace_with, config, strRegex);
 
     forEachType(pcre, reCompiled, e) {
       pcre_free(*e);
     }
     free(reCompiled);
 
     if (pcreExtra[0]) {
       forEachType(pcre_extra, pcreExtra, e) {
         #ifdef PCRE_CONFIG_JIT
         pcre_free_study(*e);
         #else
         pcre_free(*e);
         #endif
     }
       }
     free(pcreExtra);
 }
 
 void replaceWithPcre(char **l, pcre *reCompiled, pcre_extra *pcreExtra, char *replaceWith) {
     int r;
     int subStrVec[30];
     size_t len;
     size_t offset = 0;;
     int allMatch[100];
     size_t nMatch = 0;;
 
     len = strlen(*l);
     r = pcre_exec(reCompiled, pcreExtra, *l, len, 0, 0, subStrVec, 30);
 
     while ((offset < len) && (r >= 0)) {
 
         if (r == 0) {
             printf("But too many substrings were found to fit in subStrVec!\n");
             r = 30/3;
         }
 
         for (int j=0; j < r; j++) {
             allMatch[nMatch]   = subStrVec[j*2];
             allMatch[nMatch+1] = subStrVec[j*2+1];
             nMatch            += 2;
         }
 
         offset = subStrVec[1];
         r = pcre_exec(reCompiled, pcreExtra, *l, len, offset, 0, subStrVec, 30);
     }
 
     if (!nMatch) {
       return;
     }
 
     for (int i = nMatch ; i > 0 ; i-=2) {
       // replace word
       char *sBefore = emptySF();;
 
       if (allMatch[i-2]) {
         // 0 means end of string
         sBefore = sliceS(*l, 0, allMatch[i-2]);
       }
 
       char *sAfter  = sliceS(*l, allMatch[i-1], 0);
       free(*l);
       *l = catS(sBefore, replaceWith, sAfter);
       freeManyS(sBefore, sAfter);
 }
     }
 
 // -------------------------------------------------------------------------------------
 
 #ifndef unitTest
 // Remove main when running the unit tests
 #define MAIN   main
 #endif
 int MAIN(int ARGC, char** ARGV) {
     int dum UNUSED;
 
     argc = ARGC; argv = ARGV;;//
 
     replace();
 
     XSUCCESS;
 }