char *readln(void);

Inside readln I keep getting characters using getc checking that none
are illegal and so on. However, I am unsure about using the:

return(buf)

as this implies to me that a pointer to a locally defined buffer - buf
is actually being returned. As it has been defined locally at the end
of the function the space is made available for later use.

I hope I have explained the problem fairly well; can anyone help?

                        - Chris Trueman.

One of C's oddities is that an array object `acts up' when you try to
take its value.  Thus, if you have:

        char buf[100];

then `buf' is an array object containing 100 sub-objects, but the
`value' of `buf' is a pointer to the first sub-object, rather than the
100 values of the 100 sub-objects.  This is due to The Rule (detailed
in other articles).  You must memorize The Rule in order to deal with
arrays and pointers correctly, just as you must memorize the rules of
arithmetic in order to add and subtract.  The rules are in some sense
arbitrary, but they make the system work.

On the other hand, perhaps you have:

        char *buf;

In this case buf is not an array object, and its value is straightforward.

In either case, objects in C have lifetimes or *durations*.  For
ordinary variables, there are only two; these are known as `static' and
`automatic'.  Static objects last for the entire program run, while
automatic objects exist only during the execution of their enclosing
block.  Once the block exits, the objects it defined are no longer
valid.  (Whether they still exist anywhere is machine-dependent.  On
most machines, they do, and you can get in trouble because it is hard
to predict when their memory is reused, so your programs appear to work
`randomly'.)

There is an additional storage duration that has no official name; it
is often called `heap space' or `managed memory'.  Space allocated via
malloc() and its friends is good until free()d, or until the program
exits.  This space also consists of objects and can therefore hold
values.

Given the declaration:

        char *buf;

then if buf points to heap space or to a static object,

        return (buf);

returns a valid value.  On the other hand, given:

        char buf[100];

then if buf has static duration,

        return (buf);

returns a valid value (namely &buf[0]), but if buf has automatic
duration, it returns an invalid value (because &buf[0] no longer
exists, at least in principle, by the time the `return' completes).
Similarly, given:

        char xbuf[100];
        ...
        char *buf = &xbuf[0];

then:

        return (buf);

is valid if and only if xbuf still exists after the return (i.e.,
xbuf has static duration or is declared in a still-active block).
--
In-Real-Life: Chris Torek, Lawrence Berkeley Lab CSE/EE (+1 510 486 5427)

        I am presuming you want to do something in a function that gathers
data into some local variable and exit with a pointer to that data. You can
do this like so:

char *retptr;
char *foo(void);

retptr = foo();

char *foo(void) {
static char invar;
        invar = getchar();
        return(&invar);

When you declare the local _buf_ variable something like

        char buf[MAX_BUF_SIZE]; /* or whatever */

Then yes - the integrity of the space allocated for that set of charaters
is only maitained while that invocation of that function is still current.  
When you exit the function the integrity of the space is lost.

However if you declare your local variable as:

        char *buf;

and then call malloc with something like

        buf = (char *)malloc (sizeof (char) * MAX_BUF_SIZE);

(you can miss out the "sizeof (char) *" in this case because it is one (1)
but you might need if you are using a different variable type)

Then the integrity of the space pointed to by _buf_ is maintained after
that invocation of the function.  The _buf_ variable itself is lost
but the space it pointed to is not.  This way you can return _buf_ from
your funtion store it in a local varibale (of type "char *") in the calling
function and still access the array.  The local variable should be
decalred in the same way as _buf_ but there is no need for a malloc
for that variable.

Hope this helps

--
{           Michael Corbett             | TIME: Natures way of         .__o  }

{ If Murphy's Law can go wrong, it will.| happening at once.        (*)/'(*) }