char *treplace(char *data,char *search,char *replace) {
char *newline,*p;
memChunk *result,*line;
//ulong resultAllocSize;
if(!strlen(search)) return data;
#if MDEBUG2
DBG("treplace(string,se,re)","string : %s",data);
DBG("treplace(string,se,re)","search : %s",search);
DBG("treplace(string,se,re)","replace : %s",replace);
#endif
result = memReserve(INPUTLINE_BUFFER_REPLACE_SIZE);
line = memReserve(INPUTLINE_BUFFER_REPLACE_SIZE);
p=data;
while (sscanf(p,"%[^\n]",line->address)==1) {
if(p-data>strlen(data)) break;
newline=mreplace(line->address,search,replace);
memStrCat(result,newline);
if (line->address && *(p+strlen(line->address))) memStrCat(result,"\n");
else break;
p+=strlen(line->address)+1;
}
p=strdup(result->address);
memFree(result);
memFree(line);
return p;
}
memChunk *memString(char *string) {
static memChunk *buffer;
memCheckState ();
buffer = memReserve (strlen (string) + 1);
memcpy (buffer->address, string, strlen (string));
return buffer;
}
void memStrCat(memChunk *dest, char *string) {
memChunk result,*temp;
temp = memReserve (dest->size + strlen (string)+1);
result.address = dest->address + strlen (dest->address);
result.size = dest->size - strlen (dest->address) + 1;
memCopy (temp, memString (string));
memCopy (&result, temp);
memFree (temp);
}
void sreplace(char *s,char *orig,char *rep,char multi,long dsize) {
char *p;
memChunk *buffer,*string,*result;
if(!(p=strstr(s, orig))) return;
buffer=memReserve(dsize);
string=memString(s);
memCopy(buffer, string);
snprintf(buffer->address+(p-s), buffer->size-(p-s),"%s%s", rep, p+strlen(orig));
result=memString(buffer->address);
strcpy(s,result->address); //unsafe
memFree(string);
memFree(result);
memFree(buffer);
}
char *mreplace(char *string, char *se,char *rep) {
int status,i;
char noMatch=0;
regex_t re;
size_t nmatch = 16;
regmatch_t pm[nmatch];
unsigned long offset = 0;
char field[16];
char *res;
memChunk *search,*temp,*found,*ffound;
if(!string) return "";
if(!strlen(se)) return string;
if(!strcmp(se,rep)) return string;
temp = memStringReserve(string,INPUTLINE_BUFFER_REPLACE_SIZE);
search = memStringReserve(se,INPUTLINE_BUFFER_REPLACE_SIZE);
sreplace(search->address,"\\d","[0-9]",1,INPUTLINE_BUFFER_REPLACE_SIZE);
#if MDEBUG2
sData=strdup(string);
DBG("mreplace(string,se,re)","string : %s",sData);
DBG("mreplace(string,se,re)","search : %s",search->address);
DBG("mreplace(string,se,re)","replace : %s",rep);
#endif
if(regcomp(&re, search->address, REG_EXTENDED) != 0)
if(regcomp(&re, search->address, REG_EXTENDED<<1)) noMatch=1;
if((status = regexec(&re, string, nmatch, pm, 0))) noMatch=1;
if(noMatch) {
memFree(temp);
memFree(search);
return (char*)string;
}
found = memReserve(INPUTLINE_BUFFER_REPLACE_SIZE);
ffound = memReserve(INPUTLINE_BUFFER_REPLACE_SIZE);
while(!status) {
offset=strlen(temp->address)-strlen(string);
snprintf(found->address, INPUTLINE_BUFFER_REPLACE_SIZE, "%.*s",
(int)(size_t)(pm[0].rm_eo - pm[0].rm_so), &string[pm[0].rm_so]);//,&string[pm[0].rm_so]);
#if MDEBUG3
printf("------->> found \"%s\" length => %d offset[%d]\n",
found->address, strlen(temp->address),offset);
#endif
sreplace(temp->address+offset,found->address,rep,0,INPUTLINE_BUFFER_REPLACE_SIZE-offset);
for(i=1; i<nmatch; i++) {
snprintf(ffound->address,INPUTLINE_BUFFER_REPLACE_SIZE, "%.*s",
(int)(size_t)(pm[i].rm_eo - pm[i].rm_so), &string[pm[i].rm_so]);//,&string[pm[i].rm_so]);
snprintf(field,sizeof(field),"\\%d",i);
if(strlen(ffound->address)) {
sreplace(temp->address,field,ffound->address,1,INPUTLINE_BUFFER_REPLACE_SIZE);
} else {
sreplace(temp->address,field,"",1,INPUTLINE_BUFFER_REPLACE_SIZE);
continue;
}
#if MDEBUG3
printf(">> subfound %2d '%s' => '%s' length %d\n",
i,
ffound->address,
temp->address,offset);
#endif
}
if(offset<0) offset=-offset;
if(*string && strlen(string+pm[0].rm_eo)) {
string+=pm[0].rm_eo;
status = regexec(&re, string, nmatch, pm, 0);
} else {
status=-1;
}
}
#if MDEBUG2
DBG("mreplace(string,se,re)","result : %s",temp->address);
#endif
res=strdup(temp->address);
memFree(temp);
memFree(search);
memFree(found);
memFree(ffound);
return res;
}
memChunk *memStringReserve(char *string, long nbytes) {
static memChunk *buffer;
buffer=memReserve (nbytes);
memCopy (buffer, memString (string));
return buffer;
}
