src/shared/custom_output_search_replace.c

   1 #include "shared.h"
   2 char * searchAndReplace2(char* orig, char* search, char*value)
   3 {
   4   char *p;
   5   size_t total_len = strlen(orig);
   6   size_t token_len = strlen(search);
   7   size_t value_len = strlen(value);
   8
   9   int inx_start = 0;
  10   char * tmp = NULL;
  11   int tmp_offset = 0;
  12   int total_bytes_allocated = 0;
  13   int from = 0;
  14   p = strstr(orig, search);
  15   if(p==NULL)
  16   {
  17     os_strdup(orig,tmp);
  18
  19     return tmp;
  20   }
  21   if (value==NULL)
  22   {
  23     value="";
  24   }
  25   inx_start = p - orig;
  26
  27   while (p != NULL)
  28   {
  29     if (inx_start > 0)
  30     {
  31       if (tmp == NULL)
  32       {
  33         int len_to_add = (inx_start);
  34
  35         tmp = (char*) malloc(sizeof(char) * len_to_add);
  36         total_bytes_allocated += len_to_add;
  37
  38         strncpy(tmp, orig + tmp_offset, inx_start);
  39         tmp_offset = inx_start;
  40       }
  41
  42       total_bytes_allocated += value_len;
  43       tmp = (char*) realloc(tmp, total_bytes_allocated);
  44
  45       strncpy(tmp + tmp_offset, value, value_len);
  46       tmp_offset += value_len;
  47
  48
  49       p = strstr(orig + inx_start + token_len, search);
  50
  51       if(p!=NULL)
  52       {
  53         inx_start = p - orig;
  54         from = inx_start + token_len;
  55         if (inx_start - tmp_offset > 0)
  56         {
  57           total_bytes_allocated += inx_start - from;
  58           tmp = (char*) realloc(tmp, total_bytes_allocated);
  59           strncpy(tmp + tmp_offset, orig + from, inx_start - from);
  60           tmp_offset += inx_start - from;
  61         }
  62       }//No more coincidences.
  63       else
  64       {
  65         from = inx_start + token_len;
  66       }
  67     }
  68
  69   }
  70   if ((from  < total_len) && from>0)
  71   {
  72     total_bytes_allocated += total_len - from;//((from - (int)token_len) + (int)value_len);
  73     tmp = (char*) realloc(tmp, total_bytes_allocated+1);
  74     strncpy(tmp + tmp_offset, orig + from, total_len - from);
  75   }
  76   tmp[total_bytes_allocated]='\0';
  77
  78   return tmp;
  79 }
  80 #include "shared.h"
  81 char * searchAndReplace(char* orig, char* search, char*value)
  82 {
  83   char *p;
  84   size_t total_len = strlen(orig);
  85   size_t token_len = strlen(search);
  86   size_t value_len = strlen(value);
  87
  88   int inx_start = 0;
  89   char * tmp = NULL;
  90   int tmp_offset = 0;
  91   int total_bytes_allocated = 0;
  92   int from = 0;
  93   p = strstr(orig, search);
  94   if(p==NULL)
  95   {
  96     os_strdup(orig,tmp);
  97
  98     return tmp;
  99   }
 100   if (value==NULL)
 101   {
 102     value="";
 103   }
 104   inx_start = p - orig;
 105
 106   while (p != NULL)
 107   {
 108     if (inx_start > 0)
 109     {
 110       if (tmp == NULL)
 111       {
 112         int len_to_add = (inx_start);
 113
 114         tmp = (char*) malloc(sizeof(char) * len_to_add);
 115         total_bytes_allocated += len_to_add;
 116
 117         strncpy(tmp, orig + tmp_offset, inx_start);
 118         tmp_offset = inx_start;
 119       }
 120
 121       total_bytes_allocated += value_len;
 122       tmp = (char*) realloc(tmp, total_bytes_allocated);
 123
 124       strncpy(tmp + tmp_offset, value, value_len);
 125       tmp_offset += value_len;
 126
 127
 128       p = strstr(orig + inx_start + token_len, search);
 129
 130       if(p!=NULL)
 131       {
 132         inx_start = p - orig;
 133         from = inx_start + token_len;
 134         if (inx_start - tmp_offset > 0)
 135         {
 136           total_bytes_allocated += inx_start - from;
 137           tmp = (char*) realloc(tmp, total_bytes_allocated);
 138           strncpy(tmp + tmp_offset, orig + from, inx_start - from);
 139           tmp_offset += inx_start - from;
 140         }
 141       }//No more coincidences.
 142       else
 143       {
 144         from = inx_start + token_len;
 145       }
 146     }
 147
 148   }
 149   if ((from  < total_len) && from>0)
 150   {
 151     total_bytes_allocated += total_len - from;//((from - (int)token_len) + (int)value_len);
 152     tmp = (char*) realloc(tmp, total_bytes_allocated+1);
 153     strncpy(tmp + tmp_offset, orig + from, total_len - from);
 154   }
 155   tmp[total_bytes_allocated]='\0';
 156
 157   return tmp;
 158 }
 159
 160 //escape newlines characters. Returns a new allocated string.
 161 char* escape_newlines(char *orig)
 162 {
 163   const char *ptr;
 164   char *ret, *retptr;
 165   int size;
 166
 167   ptr = orig;
 168   size = 1;
 169   while (*ptr)
 170   {
 171     if ((*ptr == '\n') ||(*ptr == '\r'))
 172       size += 2;
 173     else
 174       size += 1;
 175     ptr++;
 176   }
 177
 178   ret = malloc (size);
 179   ptr = orig;
 180   retptr = ret;
 181   while (*ptr) {
 182     if (*ptr == '\n') {
 183       *retptr = '\\';
 184       *(retptr+1) = 'n';
 185       retptr += 2;
 186     }
 187     else if (*ptr == '\r') {
 188       *retptr = '\\';
 189       *(retptr+1) = 'n';
 190       retptr += 2;
 191     }
 192     else {
 193       *retptr = *ptr;
 194       retptr ++;
 195     }
 196     ptr++;
 197   }
 198   *retptr = '\0';
 199
 200   return ret;
 201 }