I've written several functions which each has a single argument (character
strings) and returns the same (char string).  I need the function to return
a character string.  Each functions implementation dynamically allocates
memory to build a string for the work that the function does.

The problem?  Two lines prior to the function's return, I strcpy the
functions malloc'd character string (variable) to the global.  The line
prior to the functions return, I "free" the malloc'd (local) variable which
really upsets the compiler (Visual C++ 6.0).  One thing........"alloca"
worked great (but another compiler I have to port to doesn't support
"alloca", hence malloc or calloc.

Here's a synopsis of the problem:

#include<stdlib.h>
#include<stdio.h>
char * gvar;
char * start(char str[])
{
   char *lvar;
   if ( (lvar = (char *)malloc( strlen(str) * 2 + 1) ) != NULL)
   {
      /* process */
      if ( strlen(gvar) < lvar)
      {
         if ( (gvar = realloc( strlen(lvar) + 1, sizeof(char) ) != NULL)
            strcpy(gvar, lvar);
      }
      free(lvar); /* ERROR */
   }
   return gvar;

Also, you leaked whatever memory that gvar originally pointed to. If
your intent was to expand the buffer for gvar, then you needed to pass
it in as the first argument to realloc().

I keyed in the code from memory (not readily before me) and made a few
mistakes that you caught (see very bottom of email for full listing).

: >    if ( (lvar = (char *)malloc( strlen(str) * 2 + 1) ) != NULL)
:
: the cast of malloc is not necessairy and potentially dangerous.
:

Saw this casting format in one of the C books I have....I'll remove it.

: >    {
: >       /* process */
: >       if ( strlen(gvar) < lvar)
:
: You compare the length of the string gvar points at to lvar ???
:

Typo......should have been
====> if (strlen(gvar) < strlen(lvar))

: >       {
: >          if ( (gvar = realloc( strlen(lvar) + 1, sizeof(char) ) != NULL)
:
: The first argument to realloc is a void * not a size_t. Read up on it in
: your favourite C book or the FAQ of this newsgroup.
:

Another typo (must have had calloc on the brain).  Should have been

=====> if ( (gvar = realloc( gvar, strlen(lvar) + 1 ) != NULL)

: >             strcpy(gvar, lvar);
:
: lvar points to unitialised memory. This is not going to work
:
: >       }
: >       free(lvar); /* ERROR */
: >    }
: >    return gvar;
: > }
: > void main(void)
:
: int main(void)
:
: > {
: >    if ( (gvar = (char *)malloc( 256) ) != NULL)
: >    {
: >       printf("%s\n", start("test"));  // would like function to return
: > character string as I next functions
: >    }
: > }
: >
: > As I said earlier, "alloca" worked fine (didn't have to "free" memory).
: > Any help would be greatly appreciated.
:

Here's the code minus typos (I hope) :-)

#include<stdlib.h>
#include<stdio.h>
char * gvar;
char * start(char str[])
{
   char *lvar;
   if ( (lvar = (char *)malloc( strlen(str) * 2 + 1) ) != NULL)
   {
      /* process */
      if ( strlen(gvar) < strlen(lvar))
      {
         if ( (gvar = realloc( gvar, sizeof(char) ) != NULL)
            strcpy(gvar, lvar);
      }
      free(lvar); /* ERROR */
   }
   return gvar;

    I've read somewhere that in earlier times when Royalty
was considered sacrosanct and semi-divine, it would have
been an egregious breach of The Right Order Of Things for
a lowly commoner to lay hands on the Royal personage.  So
when a King fell ill, it was out of the question to allow a
doctor to examine the ailing monarch.  Instead, they'd use a
stand-in of lowlier lineage; this person would simulate the
King's illness to the best of his ability, and the doctor would
examine him instead.  Court protocol was thereby satisfied,
but I have a suspicion the diagnoses may have been suboptimal.

    The cure?  #include <string.h>.

I still think you should get rid of that global var. If you want to
expand the buffer, pass in the existing pointer and either return it's
value or the newly allocated expansion. Or pass in a char** and change
the pointer's value.

Thanks for the prior posts.......unfortunately I couldn't post the original
code due to constraints beyond my control and had to key in sample thru
memory of which I made typos for which I apologize.  Here's the code with
corrections:

#include<stdlib.h>
#include<stdio.h>
char * gvar;
char * start(char str[])
{
   char *lvar;
   if ( (lvar = (char *)malloc( strlen(str) * 2 + 1) ) != NULL)
   {
      /* process */
      if ( strlen(gvar) < strlen(lvar))
      {
         if ( (gvar = realloc( gvar, sizeof(char) ) != NULL)
            strcpy(gvar, lvar);
      }
      free(lvar); /* ERROR */
   }
   return gvar;

Also, you just realloced the memory down to one byte. Is that what you
intended? I suspect not.

The following program does what I *think* you intend:

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

char *start(const char *str, char *p, size_t psize)
{
  char *newp = p;
  size_t len = strlen(str);
  if(len >= psize)
  {
    newp = realloc(p, len + 1);
  }

  if(newp != NULL)
  {
    strcpy(newp, str);
  }
  else
  {
    newp = p;
  }

  return newp;

  if(p != NULL)
  {
    p = start("test", p, 256);
    printf("%s\n", p);
    free(p);
  }

  return 0;