libsheepy

regexDemo.c (6124B)

---

 //#!/usr/bin/tcc -run
 // qwd
 
 #include "../release/libsheepy.h"
 #include "../release/libsheepy.c"
 #include "pcre.h"
 //include regex.h
 
 #define internal static
 
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
 
 void replace();
 #ifndef unitTest
 #endif
 int MAIN(int ARGC, char** ARGV);
 
 int argc; char **argv;
 
 // unsed function
 void replace() {
     char **replace_configuration = NULL;
     char **search_what = NULL;
     char **replace_with = NULL;
     char **config = NULL;
 
     printf("\nLoading config...\n");
     printf("\n");
 
     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]);
 
     enumerateCharP(search_what, e, i) {
         printf("Replace: ");
         printf("\n");
         printf("%s\n", *e);
         printf("With:");
         printf("\n");
         printf("%s\n", replace_with[i]);
     }
 
     printf("\n\nProcess files...\n");
     printf("\n");
 
     config = readText("files.txt");
 
     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;
                 }
 
                 forEachCharP(src, l) {
                     enumerateCharP(search_what, a, i) {
                         pErrorNULL(iReplaceS_max(l, *a, replace_with[i]));
                 }
                     }
 
                 bool status = writeText(*f, src);
                 if (status) {
                     printf("CHANGED:      %s", *f);
                     printf("\n");
                 }
                 else {
                     printf("DIDNT CHANGE: %s", *f);
                     printf("\n");
     }
         }
             }
                 }
 
     listFreeS(config);
 }
 
 // -------------------------------------------------------------------------------------
 
 #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;;// compile a regular expression and run on a list of strings
 
     //replace();
 
     // PERL REGEX
     // example
     // http://www.mitchr.me/SS/exampleCode/AUPG/pcre_example.c.html
 
     char *aStrRegex;
     aStrRegex = "\\bhello\\b";
     printf("Regex to use: %s\n", aStrRegex);
 
     pcre *reCompiled;
     const char *pcreErrorStr;
     int pcreErrorOffset;
     reCompiled = pcre_compile(aStrRegex, 0, &pcreErrorStr, &pcreErrorOffset, NULL);
 
     if (!reCompiled) {
         printf("ERROR: Could not study >%s<: %s", aStrRegex, pcreErrorStr);
         printf("\n");
         XFAILURE;
     }
 
     pcre_extra *pcreExtra;
     // Optimize the regex
     pcreExtra = pcre_study(reCompiled, 0, &pcreErrorStr);;
 
     if (!pcreExtra) {
         printf("ERROR: Could not study >%s<: %s", aStrRegex, pcreErrorStr);
         printf("\n");
         XFAILURE;
     }
 
     char **strings = listCreateS("This should match... helloqwe","This could match... hello!","More than one hello.. hello","No chance of a match...");
 
     forEachCharP(strings, aLineToMatch) {
         printf("String: %s", *aLineToMatch);
         printf("\n");
         printf("        %s", "0123456789012345678901234567890123456789");
         printf("\n");
         printf("        %s", "0         1         2         3");
         printf("\n");
 
         int r;
         int subStrVec[30];
         size_t len = strlen(*aLineToMatch);
         size_t offset = 0;
         r = pcre_exec(reCompiled, pcreExtra, *aLineToMatch, len, 0, 0, subStrVec, 30);
 
         if (r < 0) {
             printf("Something bad happened..");
             printf("\n");
             switch (r)
                 case PCRE_ERROR_NOMATCH:
                     printf("String did not match the pattern\n");
         }
         else {
             printf("Result: We have a match!\n");
         }
 
         while ((offset < len) && (r >= 0)) {
 
             if (r == 0) {
                 printf("But too many substrings were found to fit in subStrVec!\n");
                 r = 30/3;
             }
 
             const char *psubStrMatchStr;
             for (int j=0; j < r; j++) {
                 pcre_get_substring(*aLineToMatch, subStrVec, r, j, &(psubStrMatchStr));
                 printf("Match(%2d/%2d): (%2d,%2d): >%s<\n", j, r-1, subStrVec[j*2], subStrVec[j*2+1], psubStrMatchStr);
 
                 // replace word
                 char *sBefore = sliceS(*aLineToMatch, 0, subStrVec[j*2]);
                 char *sAfter  = sliceS(*aLineToMatch, subStrVec[j*2+1], 0);
                 printf("BEFORE >%s<", sBefore);
                 printf("\n");
                 printf("AFTER  >%s<", sAfter);
                 printf("\n");
                 freeManyS(sBefore, sAfter);
             }
 
             offset = subStrVec[1];
             r = pcre_exec(reCompiled, pcreExtra, *aLineToMatch, len, offset, 0, subStrVec, 30);
     }
         }
 
 
     pcre_free(reCompiled);
     if (pcreExtra) {
         #ifdef PCRE_CONFIG_JIT
         pcre_free_study(pcreExtra);
         #else
         pcre_free(pcreExtra);
         #endif
     }
 
     // POSIX REGEX
     /* regex_t regex; */
     /* int r; */
     /* char *regS = "str" */
     /* r = regcomp(&regex, regS, 0); */
     /* if r */
     /*     print 'regex failed to compile' */
     /*     XFAILURE; */
     /*  */
     /* regmatch_t m[30]; */
     /* char *s = "asasd str string sdfasas" */
     /* r = regexec(&regex, "asasd str sdfasas", 30, m, 0) */
     /* if !r */
     /*     print 'match' */
     /*     for int i = 0; m[i].rm_so != -1; i++ */
     /*       char * sli = sliceS(s, m[i].rm_so, m[i].rm_eo) */
     /*       print '<%d,%d> %s', m[i].rm_so, m[i].rm_eo, sli */
     /*       free sli */
     /*      */
     /* else if r = REG_NOMATCH */
     /*     print 'no match' */
     /* else */
     /*     print 'regex error' */
     /*  */
     /* regfree(&regex); */
 
     XSUCCESS;
 }