Find and Replace Text Function

im working on a find and replace text function now, with not alot of luck

heres what i have so far

Code:

---

int replace(char *source, char search[], char replace[]) {
    char *value = (char *)malloc( ( strlen(source) - strlen(search) ) + strlen(replace) );

    char *start = strstr(source, search);
    strncpy(value, source, *start);
   
    printf("%s\n", value);
   
    return 0;
}

int main() {
    char temp[] = "testing a new idea";
    replace(temp, "new", "WORKING");


    return 0;
}

---

i want to look for string search in string source and copy it to a seperate string. then i want to strcat the replace and copy what was left over from string.

right now the strncpy(value, source, *start); line doesnt seem to be working. i now its a memory adress im giving it, but is there and way i can use it like a subscript?

i was think about making a function to figure out the subscript from the address and the string name, but it really cant be done. characters can repeat them self.

Quote:

---

i was think about making a function to figure out the subscript from the address and the string name, but it really cant be done. characters can repeat them self.

---

if there isnt another solution, couldnt i play with the address themselves? i mean take the char's address and subtract from the first char in string and divide by how big a char is? how could i get the first node's address(making a pointer to it seems like a waste)? can i assign pointers by addresses(is that a good idea in a os like linux)?

to many questions, to little code..........

Code:

---

int replace(char *source, char search[], char replace[]) {
/* We add 1 to account for the null terminator */
    char *value = (char *)malloc( ( strlen(source) - strlen(search) ) + strlen(replace) + 1 );

/* check malloc */
    if (value == NULL) return 0;

/* null initialise value */
    value[0] = '\0';

    char *start = strstr(source, search);
/* check that search was found */
    if (start == NULL) return 0;

    /* We get number of characters by taking source address from
        start address. We use strncat as it always appends a
        null while strncpy does not. This is why we null initialised
        value */
    strncat(value, source,(int) start - (int) source);

    /* Append the replacement */
    strcat(value,replace);

    /* Append the rest of the string following the search string */
    strcat(value,start + strlen(replace) );

    printf("%s\n", value);
   
    return 0;
}

---

Seeing your second post I think you have the idea. Good luck.

The biggest problem with this design is if the replacement string is larger than the search string, there's no safe way to determine whether the pointer you get can be realloc'd, so you're stuck with assuming that the size is fixed and that the replacement would overrun the boundaries. You'll have to settle with returning a completely new string and have the caller handle copying into the source string:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char *replace ( const char *src, const char *find, const char *repl )
{
  char *found;
  /*
  ** Create enough space for the source string
  ** and the replacement string to be added.
  ** Don't forget one slot for the nul char.
  */
  char *new_src = malloc ( strlen ( src ) + strlen ( repl ) + 1 );

  /* No recovery possible, return failure */
  if ( new_src == NULL )
    return NULL;

  found = strstr ( src, find );

  /* Search string not found, return the whole of the source */
  if ( found == NULL ) {
    strcpy ( new_src, src );
    return new_src;
  }

  /* Paste the replacement string in */
  strncpy ( new_src, src, (size_t)(found - src) );
  strcat ( new_src, repl );
  strcat ( new_src, found + strlen ( find ) );

  return new_src;
}

int main ( void )
{
  char *modified;
  char a[] = "This is a test";

  modified = replace ( a, "a", "another" );

  puts ( modified );
  free ( modified );

  return 0;
}

---

And to all previous posters, always free your allocated memory. :)

-Prelude

not much here, the last part of your code doesnt work right. the strcat part doesnt copy all of the remaining test. thanks for the begining tho.

prelude, your code works, but i dont understand how. why wont strcat(value, start + strlen(replace)); work correctly?

thanks

>prelude, your code works
I sure hope so. Posting broken code is embarassing :)

>but i dont understand how
This is a good time to walk through the code with a debugger, that way you can see exactly what changes are being made:

Code:

---

--static char *replace ( const char *src, const char *find, const char *repl )
src = "This is a test"
find = "a"
repl = "another"

--found = strstr ( src, find );
found = "a test"

--strncpy ( new_src, src, (size_t)(found - src) );
found - src = 8
new_src = "This is "

--strcat ( new_src, repl );
new_src = "This is another "

--strcat ( new_src, found + strlen ( find ) );
found + strlen ( find ) = " test"
new_src = "This is another test"

---

-Prelude

why wont something like this work right?

Code:

---

int replace(char *src, char find[], char replace[]) {
    char *value = malloc( strlen(src) - strlen(find) + strlen(replace) + 1 );
        strcpy(value, src);
       
    char *found = strstr(value, find);

    value[*found] = '\0';
    strcat(value, replace);
    strcat(value, found + strlen(replace));

    printf("%s", value);
    strcpy(src, value);
    free(value);
   
    return 0;
}

---

What if the block value points to is smaller than the string source points to?

lets see if i got this right now, you can give strcat a position and it keeps going until it finds a \0? so it does do it char by char?

so why doesnt this compile(the addto function)?

Code:

---

int copy(char *src, char *dest, int *start, int end) {
    char *value = (char *)malloc(end - *start);
    int x = 0;
   
    if(end == 0)
        end = strlen(src);
   
    while(src[*start] < end) {
        value[x] = src[*start];
       
        ++x;
        ++*start;
    }
   
    return 0;
}

int addto(char *src, char data[], int start) {
    char value[ strlen(src) ];
        strcpy(value, src);
    char buff[ strlen(src) - start + 1 ];
       
    value[start] = '\0';
    strcat(value, data);
    strcat(value, src[start]);
   
    printf("%s\n", value);
   
    return 0;
}

int main() {
    char temp[25] = "testing a new idea";
    addto(temp, "working", 14);

    return 0;
}

---

it doesnt like the strcat(value, src[start]); part, but why? start is a number and a number is a subscript.

Code:

---

strcat(value,start + strlen(replace) );

should of course read:

strcat(value,start + strlen(search) );

---

My apologies.

Prelude, your code is essentially the same as mine (without the small bug).
However:

Code:

---

strncpy ( new_src, src, (size_t)(found - src) );
strcat ( new_src, repl );

---

The docs say that strncpy does not append a null character. So this should fail unless new_src is all nulls.

http://www.opengroup.org/onlinepubs/...s/strncpy.html

>>The docs say that strncpy does not append a null character.
OK, I'm late into this conversation, but... This statement is incorrect, and your link proves it:

Quote:

---

If the array pointed to by s2 is a string that is shorter than n bytes, null bytes shall be appended to the copy in the array pointed to by s1, until n bytes in all are written.

---

So, in short is isn't guaranteed to write a nul, but providing the string fits, it will.

I challenge you to a duel at dawn. :-)

Code:

---

char *strncpy(char *restrict s1, const char *restrict s2, size_t n);

---

You should reread the entire documentation.

Quote:

---

If the array pointed to by s2 is a string that is shorter than n bytes, null bytes shall be appended to the copy...

---

If string s2 is shorter that n bytes then we do not need to use strncpy we could just use strcpy. The whole idea of strncpy is that we want to copy only the first n bytes from s2.

Code:

---

char s1[50]; /* random data */
char s2[] = "We want to copy the first 10 chars of s2";
strncpy(s1,s2,10); /* s2 is not shorter than n bytes */

---

s1 now contains the first ten chars of s2 and is not null terminated.
If you had read the entire doc you would have found this:

Quote:

---

If there is no null byte in the first n bytes of the array pointed to by s2, the result is not null-terminated.

---

I'm sure you would agree that there is no null byte in the first ten characters of s2 above.

Code:

---

strncpy ( new_src, src, (size_t)(found - src) );

---

Again, there is no null in the first n bytes of src.

This would work:

Code:

---

char s1[50];
char s2[] = "test";
strncpy(s1,s2,50); /* = strcpy(s1,s2); */

---

but is a pointless exercise.

or from MSDN:

Quote:

---

If count is less than or equal to the length of strSource, a null character is not appended automatically to the copied string.

---

Code:

---

char * strncpy(char * s1, char * s2, size_t n) {
        memset(s1, 0, n);
        memcpy(s1, s2, min(strlen(s2), n) );
}

---

OK, OK, damn and blast,
Rereading your post, you are technically correct. Although , practically and in the context of this thread your info is still quite useless.

If I bothered to sign in I wouldn't make such a fool of myself.
Ah well, that's life.

To finish this discussion, there is three ways to use strncpy.
A. Make sure your destination string is null filled before using it.
B. Null terminate your destination string after using strncpy.
C. Accept that the destination string will not be null terminated. Ie. Treat it like binary data.

>>OK, OK, damn and blast,
>>Rereading your post, you are technically correct
Damn, I'd just written a nice reply too. :D Oh well, I've deleted it and I'll make my summary by quoting myself:
>>strncpy() ... isn't guaranteed to write a nul

We're done :)

i was about to fix up the replace function up alittle more and i attempt to but the process in a loop in case string search is in src a couple times

Code:

---

int replace(char *src, char search[], char replace[]) {
    char *value = malloc( strlen(src) - strlen(search) + strlen(replace) +1 );
   
    char *found;
   
    while(found != NULL) { /* never ends, why? */
        found = strstr(src, search);
    }

    printf("%s", value);
    free(value);
    return 0;
}

---

my while loop never ends, why? i thought the fact that a pointer is never NULL would make this work. unfortunally im doing this in windows again, but if its wrong why wouldnt i get a seg fault for checking out memory thats not mine?

>>found = strstr(src, search);
strchr() is being asked to look for the same thing each time the loop goes round, so it will return the same answer.

Also, the value of found is undefined the first time into the loop.

Quote:

---

strchr() is being asked to look for the same thing each time the loop goes round, so it will return the same answer.

---

doesnt it increment itself so it can look for a string more than once? can i make it?

Quote:

---

Originally posted by mart_man00
doesnt it increment itself so it can look for a string more than once? can i make it?

---

No. It doesn't. No, you can't. That is to say, you can't change the function itself. You can change what you pass to it:

Code:

---

for( something = strchr( somestring, somechar ); sometest; something = strchr( something +1, somechar ) );

---

That should work. Initialize it by having the return value of the initialization be stored in 'something'. Use subsequent calls to check 'something', updating it on each call.

Naturally you'll want better error checking than what I use.

Quzah.

>>doesnt it increment itself so it can look for a string more than once?
No, you need to update the pointers you pass to strstr() each time.

Code:

---

#include <stdio.h>
#include <string.h>

int main(void)
{
  char  buf[] = "this is something is blah is OK";
  char  *p;
 
  puts(buf);
  for (p = buf; p = strstr(p, "is"); p++)
    puts(p);

  return(0);
}

/*
 * Output:
this is something is blah is OK
is is something is blah is OK
is something is blah is OK
is blah is OK
is OK
 
*/

---

[edit]Doh, beaten :D

i tried to rewrite my function so it will look more than once, but with no luck. any one see why?

Code:

---

int replace(char *src, char search[], char replace[]) {
        char *value = malloc(strlen(src) - strlen(search) + strlen(replace) + 1 );
            char check[ strlen(src) + 1 ];

        char *found = src;
        char *spot = src;
   
            while(*spot != '\0' && found != NULL) {
                found = strstr(spot, search);
               
                if( strcmp(found, check) != 0 ) {
                        printf("%s\n", found);
                       
                        strncat(value, spot, found - src);
                        strcat(value, replace);
                        strcat(value, found + strlen(search));

                        printf("\t%s\n", value);
                }

                strcpy(check, found);
                ++*spot;                               
        }
           
        free(value);
           
        return 0;
}

---

Code:

---

char *value = malloc(strlen(src) - strlen(search) + strlen(replace) + 1 );

---

Never assume passed argument pointers are non-NULL. Always check before using them.

Code:

---

char check[ strlen(src) + 1 ];

---

Variable length arrays are not part of the pre-C99 standard. It's doubtful your compiler actually is a C99 compiler. Avoid this.

Code:

---

strcpy(check, found);
++*spot;

---

Why are you dereferencing this pointer? You shouldn't be.

Finally, what is the purpose of value? Debugging, or what?

Quzah.

value is a just a temp varible to work with, it will eventually get copied to src.

im using gcc for this, and it works, just only once. char check[ strlen(src) + 1 ]; doesnt seem right, atleast with my malloc call i get exactly how much i need.

im really not sure what to do here now, im alittle confused. i dont see why this wouldnt work. how would you guys do this?

Quote:

---

Originally posted by mart_man00
char check[ strlen(src) + 1 ]; doesnt seem right, atleast with my malloc call i get exactly how much i need.

---

Um... that line of code is from your example. I was pointing out that variable sized arrays, such as the one listed above, is not part of the pre-C99 standard. (IE: It's bad form.)

Quzah.

can any one show me how they would write this function, im getting now where. i just want it to scan a string for a string and replace ever occurence.

heres my most recent failure

Code:

---

int replace(char *src, char search[], char replace[]) {
    char *value = malloc( strlen(src) + 1);
        value[0] = '\0';
    char *spot = src;
    char *found = src;
   
    char check[ strlen(src) ];
   
    while(spot != NULL && (found = strstr(spot, search)) != NULL ) {
        if( strcmp(found, check) != 0 ) {
            realloc(value, strlen(found) + 1);  /* Problem here, how do i find the length of everything before found? */
            strncat(value, spot, found - src);

            realloc(value, strlen(replace) + 1);
            strcat(value, replace);
           
            realloc(value, strlen(found) + 1);
            strcat(value, found + strlen(search));
        }
       
        printf("\n%s\n", value);
        strcpy(check, found);
        ++spot;
    }

    free(value);
    strcpy(src, value);
   
    return 0;
}

---

i think its time to learn by example.............................


im also getting garbage data somewhere.

This will search and replace with larger or smaller text. First count the number of replacements then allocate a new buffer from the count, then copy the old buffer+replacement text to the new buffer in the while loop.

Code:

---

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void replace(char **newbuffer, char *source, char *search, char *replace)
{
        int count=0,slen = strlen(search),rlen = strlen(replace);
        char *s1 = source;

        while(s1 = strstr(s1, search))
        {
                count++;
                s1 += slen;
        }
//        char *n1 = *newbuffer = new char[ strlen(source)+((strlen(replace)-slen)* count)+1 ];
        char *n1 = *newbuffer = (char *) malloc( strlen(source)+((strlen(replace)-slen)* count)+1 );
        s1 = source;

        while(s1 = strstr(s1, search))
        {
                strncpy(n1,source, s1-source);
                  n1 += s1-source;
                strcpy(n1,replace);
                n1 += rlen;
                s1 += slen;
                source = s1;
        }
        strcpy(n1, source );
}

int main()
{
        char temp2[] = "testing a new idea, testing a new idea, testing a new idea";
        char *newbuffer;
       
        //replacing with larger
        replace(&newbuffer, temp2, "new", "WORKING");
        printf("%s\n", newbuffer);
//        delete [] newbuffer;
        free(newbuffer);

      //replacing with smaller
        replace(&newbuffer, temp2, "new", "X");
        printf("%s\n", newbuffer);
//        delete [] newbuffer;
        free(newbuffer);

        return 0;
}

---

For the record, delete and new are C++ operators, and are not available in C.

Quzah.

I was just showing the program structure, but just replace 'new' and 'delete' with the following code 'malloc()' and 'free()':

Code:

---

char *n1 = *newbuffer = (char *) malloc( strlen(source)+((strlen(replace)-slen)* count)+1 );

free(newbuffer);

---

I have corrected the post,
Cheers....

Thanks Scarlet7,
I have been wrestling with a way to implement replacing of multiple instances of multiple different place holders in a string.
Your way will work very nicely and about ten times more efficiently than what I had been thinking of.

I think it will be something like this:

Code:

---

struct found {
lpstr placeholder
lpstr replace
lpstr position
}

for (loop through placeholders)
  while _tcsstr(src, placeholders[i]) {
    add replace length to length needed
    add found pointer to array of found structs
  }
}

sort array of found structs  by the position
member so that those
first in the string are first in the array.

allocate required mem for dest

for (loop through array of found structs.) {
  memcpy(dest,src, foundstruct[i].position - src)
  dest+= (.position - src)
  src = .position + strlen(.placeholder)
  memcpy(dest, .replace, strlen(replace) )
  dest += strlen(replace);
}

---

i tried doing it diferently and playing with the code you guys gave me, but i still cant get it right myself.

any one see why this seg faults?

Code:

---

int replace(char *src, char search[], char replace[]) {
  int search_length = strlen(search);  /* String lengths to be used later for copying. */
  int replace_length = strlen(replace);

  int count = 0;  /* Number of times spent looking for search.  */
  int time = 0;  /* Number of replacements needed. */

  char *value = NULL;
   
  char *find;    /* String position info. */
  char *next_find;
  char *spot = src;

  while( (find = strstr(spot, search)) != NULL ) { /* Figure out how many replacements must be made. */
    ++count;

    spot += search_length;
  }

  spot -= (search_length * count);  /* Reset spot to orignal location. */

  if(count > 0) {
    while(time < count) {
      find = strstr(spot, search);                      /* Find where the search is. */
      next_find = strstr(spot + search_length, search); /* Find where to end the copy. */

      realloc(value, find - spot + 1);
      /* ***Problem start here*** */
      strncat(value, spot, find - spot);                /* Copy everything before search. */

      realloc(value, replace_length + 1);
      strcat(value, replace);                          /* Add the replacement text. */
                                         
      spot += (replace_length + 1);                    /* Update spot's location. */
      realloc(value, next_find - spot + 1);
      strncat(value, spot, next_find - spot);          /* Copy everything in between searches. */
    }
  }

  strcpy(src, value); /* The long awaited lines... */                     
  free(value);
 
  return 0;
}

---

Code:

---

while( (find = strstr(spot, search)) != NULL ) { /* Figure out how many replacements must be made. */
    ++count;

    spot += search_length;
}
spot -= (search_length * count);

---

This is wrong. Consider the following:

"the dog and the fish went to the store"

You're finding "the".
Your loop makes count equal three.
However, 'spot' points to the last 'the'.

spot = spot - ( 3 * strlen( "the" ) );

You only move back 9 characters. This is not the start of the string. This is not the start of anything. This is some arbitrary point in the middle of your string.

Simply call strstr for the first time again on the source string instead.

spot = strstr( src, search );

Now you correctly point to the first one.

[edit]
What you should be doing is this:
1) Count the number of items to replace.
2) Get the modified string length:
... a) s1 = count * strlen( search )
... b) r1 = count * strlen( replace )
... c) r1 < s1 ? no need to reallocate : reallocate space, adding r1-s1 more bytes.
3) Malloc the space you need.
4) Copy until the first replace spot.
5) Copy the first "replace" string in.
6) Continue copying from the original string past the first spot until the next.
7) Repeat 5 and 6 until you're done.
8) Add on any remainder string.

Now you could use realloc, but personally, I'd malloc a new string, then call realloc on the original once I was done and copy the new string in its place. Or, pass it a poitner to a pointer, and just update that, freeing the original.
[/edit]

Quzah.

im sure doing obviously wrong here but it still seg faults

Code:

---

int replace(char *src, char search[], char replace[]) {
  int search_length = strlen(search);  /* String lengths to be used later for copying. */
  int replace_length = strlen(replace);

  char *value = NULL;
   
  char *find;    /* String position info. */
  char *next_find = NULL;
  char *spot = src;

  spot = src;  /* Reset spot to orignal location. */

  while( (find = strstr(spot, search)) != NULL  && spot != '\0' ) {
    printf("\nTest 1\n");
    next_find = strstr(spot + search_length, search);

    printf("\nTest 2\n"); /*Crash starts here */
    realloc(value, find - spot + 1);
    strncat(value, spot, find - spot);

    printf("\nTest 3\n");
    realloc(value, replace_length + 1);
    strcat(value, replace);

    printf("\nTest 4\n");
    spot += replace_length;
    realloc(value, next_find - spot + 1);
    strncat(value, spot, find - spot);
  }

  strcpy(src, value);
  free(value);
 
  return 0;
}

---

Here's few problems to start with:

1. 'spot' should be 'find' in
next_find = strstr(spot + search_length, search);

2. realloc returns the new pointer so it should be:
value = (char*)realloc(value, find - spot + 1);
this is whats causing the crash, value = NULL.

3. when 2. is fixed initialize value as it will contain rubbish and
strncat will add to end of the rubbish. Init only once!

4. ?

I would suspect the call to realloc. To me it looks something like this.

Code:

---

int main(void)
{
    char *ptr;
    malloc(50);
    strcpy(ptr, "Was that return value important?");
    return 0;
}

---

Here is a recent example using realloc.

>> value = (char*)realloc(value, find - spot + 1);
>>this is whats causing the crash, value = NULL.
I'm not sure I get what you mean, but if you're saying that the first parameter to the realloc() function is NULL and will therefore cause a crash, you are incorrect. If the first parm is NULL, realloc() merely acts like malloc().

This issue is hugely overcomplicated. Do (again) what I already stated:

1) Count the needed replacements.

Code:

---

while( (find = strstr(spot, search)) != NULL ) {
    ++count;
    spot += search_length;
}

---

2) Do the math.

Code:

---

difference = count * search_length < replace_length ? replace_length :
    (search_length-replace_length);

---

3) Malloc a new block.

Code:

---

newptr = malloc( strlen( original ) + difference + 1 );

---

4) Repeat the following until you're at the end of the original string:
... a) copy from the original string to the new one, up to the "search" spot.
.... b) advance that pointer past the spot.
.... c) copy the "replace" text to the new string

5) Null terminate your new string.
6) Do one of the following:
... a) Make the original pointer point at the new string, free the old
... b) Realloc the original string to the length (+1) of the new string, then copy the new string over it and free the new one.

It's VERY simple. The answer has been provided multiple times. Why do I get the feeling I'm beating my head into a wall explaing this to you?

Quzah.

Quote:

---

Why do I get the feeling I'm beating my head into a wall explaing this to you?

---

probally because im not going to copy and paste anything! i am trying to learn this. im writing what i learned, im not that worried with the code, yet. so instead of taking your answers im gonna screw up for awhile until i come up with my own. ill stop if i have a feeling im giving some one a concussion, thats about all ill stop at.

im not really seeing why i have to have a replacement count at all now. that seems like it would complicate it.

i have to look for the replacements and change all of them. so i need 2 points. i stop before the first, insert the replace and copy untill the 2nd point. then i have to start it over again. using realloc seems to be alittle easier right now, but that might change.

This thread and its companion have been quite animated; I've enjoyed playing along at home. Since the main players seem to be throwing in the towel, I thought I'd post my latest for comment.

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 * Description:
 *  Find and replace text within a string.
 *
 * Parameters:
 *  src  (in) - pointer to source string
 *  from (in) - pointer to search text
 *  to  (in) - pointer to replacement text
 *
 * Returns:
 *  Returns a pointer to dynamically-allocated memory containing string
 *  with occurences of the text pointed to by 'from' replaced by with the
 *  text pointed to by 'to'.
 */
char *replace(const char *src, const char *from, const char *to)
{
  /*
    * Find out the lengths of the source string, text to replace, and
    * the replacement text.
    */
  size_t size    = strlen(src) + 1;
  size_t fromlen = strlen(from);
  size_t tolen  = strlen(to);
  /*
    * Allocate the first chunk with enough for the original string.
    */
  char *value = malloc(size);
  /*
    * We need to return 'value', so let's make a copy to mess around with.
    */
  char *dst = value;
  /*
    * Before we begin, let's see if malloc was successful.
    */
  if ( value != NULL )
  {
      /*
      * Loop until no matches are found.
      */
      for ( ;; )
      {
        /*
          * Try to find the search text.
          */
        const char *match = strstr(src, from);
        if ( match != NULL )
        {
            /*
            * Found search text at location 'match'. :)
            * Find out how many characters to copy up to the 'match'.
            */
            size_t count = match - src;
            /*
            * We are going to realloc, and for that we will need a
            * temporary pointer for safe usage.
            */
            char *temp;
            /*
            * Calculate the total size the string will be after the
            * replacement is performed.
            */
            size += tolen - fromlen;
            /*
            * Attempt to realloc memory for the new size.
            */
            temp = realloc(value, size);
            if ( temp == NULL )
            {
              /*
                * Attempt to realloc failed. Free the previously malloc'd
                * memory and return with our tail between our legs. :(
                */
              free(value);
              return NULL;
            }
            /*
            * The call to realloc was successful. :) But we'll want to
            * return 'value' eventually, so let's point it to the memory
            * that we are now working with.
            */
            value = temp;
            /*
            * Copy from the source to the point where we matched. Then
            * move the source pointer ahead by the amount we copied. And
            * move the destination pointer ahead by the same amount.
            */
            memmove(dst, src, count);
            src += count;
            dst += count;
            /*
            * Now copy in the replacement text 'to' at the position of
            * the match. Adjust the source pointer by the text we replaced.
            * Adjust the destination pointer by the amount of replacement
            * text.
            */
            memmove(dst, to, tolen);
            src += fromlen;
            dst += tolen;
        }
        else /* No match found. */
        {
            /*
            * Copy any remaining part of the string. This includes the null
            * termination character.
            */
            strcpy(dst, src);
            break;
        }
      }
  }
  return value;
}

void test(const char *source, const char *search, const char *repl)
{
  char *after;
  after = replace(source, search, repl);
  printf("\nsearch = \"%s\", repl = \"%s\"\n", search, repl);
  if ( after != NULL )
  {
      printf("after  = \"%s\"\n", after);
      free(after);
  }
}

int main(void)
{
  const char before[] = "the rain in Spain falls mainly on the plain";
  printf("before = \"%s\"\n", before);
  test(before, "the", "THEE");
  test(before, "the", "A");
  test(before, "cat", "DOG");
  test(before, "plain", "PLANE");
  test(before, "ain", "AINLY");
  return 0;
}

/* my output
before = "the rain in Spain falls mainly on the plain"

search = "the", repl = "THEE"
after  = "THEE rain in Spain falls mainly on THEE plain"

search = "the", repl = "A"
after  = "A rain in Spain falls mainly on A plain"

search = "cat", repl = "DOG"
after  = "the rain in Spain falls mainly on the plain"

search = "plain", repl = "PLANE"
after  = "the rain in Spain falls mainly on the PLANE"

search = "ain", repl = "AINLY"
after  = "the rAINLY in SpAINLY falls mAINLYly on the plAINLY"
*/

---

>.I'm not sure I get what you mean, but if you're saying that the
> first parameter to the realloc() function is NULL and will therefore
> cause a crash, you are incorrect. If the first parm is NULL,
> realloc() merely acts like malloc().
Hammer,

The address of 'value' after the first realloc was still NULL, the
crash happens when 'value' is used in the following lines of code.
Realloc returns the new address, and the address of realloc can change.
Passing 'value' to realloc does not update its pointer.

realloc(value,,) should have been value=realoc(value,,)

>>realloc(value,,) should have been value=realoc(value,,)
Ideally it should have been
>>tmpvalue=realloc(value,,)
to be on the safe side. Remember that if value already points to malloc'd memory, and realloc fails, your version will loose the pointer value and create a leak. Using a different, temporary pointer to catch the return from realloc() enables you to test it for NULL first, and then assign the value to value.
>>value = tmpvalue;

a couple more questions here, why did you use size_t and memmove?

and i still dont get why some of my other versions dont work, like this (its only the millionth time i tried, ill guess righ eventually, righ?)

Code:

---

int replace(char *src, char search[], char replace[]) {
  int search_length = strlen(search);
  int replace_length = strlen(replace);

  char *value = NULL;
  char *spot = src;

  char *first = NULL;
  char *next = NULL;

  while(spot != '\0') {
      first = strstr(spot, search);
      next = strstr(spot + search_length, search);

      if(first != NULL) {
          if(next != NULL) {
            value = realloc(value, first - spot + 1);
            strncpy(value, spot, first - spot);

            value = realloc(value, replace_length);
            strcat(value, replace);

            spot += search_length + 1;
            value = realloc(value, next - spot + 1);
            strncat(value, spot, next - spot);
          } else {
            value = realloc(value, first - spot + 1);
            strncat(value, spot, first - spot);

            value = realloc(value, replace_length + 1);
            strcat(value, replace);

            spot += search_length + 1;
            value = realloc(value, strlen(spot) + 1);
            strcat(value, spot);
          }
      } else {
        value = realloc(value, strlen(spot) + 1);
        strcat(value, spot);
      }

  printf("\n\tvalue = %s\n", value);
  }

  strcpy(src, value);
  if(value != NULL)
    free(value);
   
  return 0;
}

---

>why did you use size_t and memmove?
I used size_t in part because that is the return value of strlen. I used memmove because an earlier version I was developing attempted to modify the string in place -- where overlap would occur.

Code:

---

value = realloc(value, length);

---

This is something to avoid, the point of my somewhat sarcastic response. If realloc fails, you cannot free the previously allocated memory (as has been pointed out already several times). This may not be the cause of your troubles, but it doesn't help to pick up bad habits as you go.

To me it seems likely that a problem would be asking realloc for the wrong amount of memory and/or writing where you don't have access. Where are you keeping track of the total string length? And it is a good idea to check whether a pointer is NULL before using it.

Another thing that has been bothering me in your posts is this.

Code:

---

int replace(char *src, char search[], char replace[])

---

It doesn't help to have ambiguous symbols.

Quote:

---

Where are you keeping track of the total string length?

---

my while loop is supposed to stop everything when \0 is found
.

Quote:

---

This is something to avoid, the point of my somewhat sarcastic response. If realloc fails, you cannot free the previously allocated memory (as has been pointed out already several times).

---

and yes, i remembered about realloc, im just more worried about getting it work once, ill try to make it work relibly next.

do you think me not using memmove is the problem? i thought all the cats remove the \0 and add the text and add another \0

>do you think me not using memmove is the problem?
No.

>my while loop is supposed to stop everything when \0 is found
Yes, but when you allocate memory, you need to ask for some amount that will contain the whole string.

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
  const char search[] = "this";
  const char replace[] = "these";
  const char src[] = "so this is the first occurrence and this is the second";
  size_t search_length = strlen(search);
  size_t replace_length = strlen(replace);
  char *first = strstr(src, search);
  char *spot  = strstr(first + search_length, search);
  size_t length = spot - first + 1;
  printf("src = \"%s\"\n", src);
  printf("search = \"%s\"\n", search);
  printf("first = \"%s\"\n", first);
  printf("spot = \"%s\"\n", spot);
  /*
  value = realloc(value, first - spot + 1);
  strncpy(value, spot, first - spot);
 
  value = realloc(value, replace_length);
  strcat(value, replace);
  */
  printf("first - spot + 1 = %lu\n", first - spot + 1);
  printf("length = %lu\n", length);
  printf("replace_length = %lu\n", replace_length);
  return 0;
}

/* my output
src = "so this is the first occurrence and this is the second"
search = "this"
first = "this is the first occurrence and this is the second"
spot = "this is the second"
first - spot + 1 = 4294967264
length = 34
replace_length = 5
*/

---

From your code in the comments, you first attempt to provide allocation for what would be a negative amount of memory. But since realloc takes an unsigned 2nd parameter, it converts it to some really big number. If this succeeds, you pad this string with more than enough null bytes, because again the negative number is taken by strncpy as a large positive value.

But then you realloc to only the length of the replace text, 5 bytes. And then attempt to concatenate (the original size, null-terminated 33 bytes, plus the new 5) into the 5 bytes you've allocated. :(

Or something like that. You need to keep a running total of the size of the whole string for memory allocation purposes...

>and yes, i remembered about realloc, im just more worried about getting it work once, ill try to make it work relibly next.

...which is why it can be better to put safety first.

Some one seriously needs to kill this thread. The original poster has been given multiple working examples, or at least the theory to get it working, and they continually ignore the examples. Furthermore, they blatently ignore lessons on how to write safe code. Yet time and time again, they keep returning wondering why it doesn't work.

They obviously don't care to learn, or they would have learned something by now. There are multiple examples to learn from, they just intentionally disregard said examples.

Quzah.