memory use

[Michael]

In the below example, I beleive that the char array buffer[40] should
only occupy 40 bytes of the stack within the inner braces.

However the compiler seems to use 40 bytes of the stack througout the
entire function that this example is cut from. Is this normal?

if(midnightflag ==1)
{
lcd_clear();
lcd_locate(1,1) ;
lcd_display("Up dating date");
{ unsigned char buffer[40];
daydateyear(buf fer);
senduart2(buffe r);
senduart2("\r\n ");
};
update_date();
midnightflag=0;
};

[Keith Thompson]

Robert Harris <ro************ *****@blueyonde r.co.uk> writes:

Michael wrote:

[snip]
Sorry my question wasn't very clear, what I wanted to know was:
In the code below (whether using a stack or not), should the char
array buffer[] occupy memory for the entire function which this code
is cut from (even though it is only accessible within the braces), OR,
should it only occupy memory within the braces. I would have thought
the latter, but maybe this is not a requirement of standard C.

Definitely the latter (see section 6.2.4 of the standard). The former
behaviour is often achieved with the alloca() function.

The alloca() function is non-standard.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Herbert Rosenau]

On Tue, 26 Oct 2004 23:42:39 UTC, ai***@acay.com. au (Peter Nilsson)
wrote:

mi*****@clift.c om.au (Michael) wrote...

In the below example, I beleive that the char array buffer[40] should
only occupy 40 bytes of the stack within the inner braces.

As far as the language specification is concerned automatic data will
only be allocated at the point of declaration, and will expire at the
end of the enclosing block scope.

No. You gets confused with visibility and reserved space. It is
completely legal theat an compuler will allocate the maximum used
space in asingle block for auto variables.

void f(void) {

if (x1)
{ int a[100]; }
if (x2)
{ int a; }
if (x3)
{
struct st {
int a, b, c, d;
double dd[999];
} s[10];
}

}

The compiler may or may not eleminate any unused variable - so giving
f() as above it may even eleminate any call of f() when the definition
of the function is visible, it may eleminate the whole body of the
fuction when it has nothing more as above, reducing it to a simple
return.

Assuming that each inner block has code that works with the variables
defined there it may allocate one single memory block big enough to
hold the biggest of all memory areas only while overlapping the
shorter ones, it may simply add the sizes and reserve the whole
storage or it can do whatever it likes to have the memory needed in
each block available. The only that the compiler will guarantee when
it defines itself as standard compatible is to have each variable only
visible in the block it is defined.

It may change its behavior depending on flags given to it at
compiletime. It may change its behavior between subversions or full
versions of itself.

There must not even a stack available. Any possible memory handling to
reserve a properitary chunk of memory that is used only inside the
function and its inner blocks and making the variables visible only
inside the inner blocks fullyfies the requirements of the standard
perfectly.

--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation

[Michael]

mi*****@clift.c om.au (Michael) wrote in message news:<ec******* *************** ****@posting.go ogle.com>...
Thanks again to all who responded.