Internals of how variable scoping works

[Omari Norman]

Greetings,

Take for instance the following code:

int main()
{
int x=5;
if (x == 5)
{
int y = 10;
}
return 0;
}

Of course x and y are in different scopes. What I am wondering is how
this works at a lower level. For instance, I know that typically
automatic variables are kept on the stack, and that function calls
cause the stack to be pushed down. I read a book that likened the
stack to index cards, with each function call getting its own index
card with its automatic variables.

So what happens when a new scope is entered, as here with the y=10
statement? I would think that the program does not create space for
the y variable when it first starts executing, because it doesn't
"know" whether that scope will ever get entered. So does the program
simply allocate additional room on the same frame in the stack when it
enters the new scope, or does it have to push the stack again to make
room for new variables?

I know this might vary from one implementation to another, but I just
want an idea how it generally works. I know my understanding is really
rudimentary so any pointers to useful sites or books would be great.
Thanks. --Omari

[WDS]

On Jun 24, 4:21*pm, Omari Norman <[e-mail]:

I know this might vary from one implementation to another, but I just
want an idea how it generally works.

I would guess that most compilers reserve space for automatic
variables at a procedural level because it is easy. A clever compiler
could save space by allocating the most that could possibly be needed
and then overlaying the variables in disjoint scopes.

I just tried something with gCC and MS Visual C++. gCC did reuse
stack space in disjoint scopes. Visual C++ reused it if compiled with
optimization but not if compiled for debug.

[Jerry Coffin]

In article <fa707fd9-d634-41b1-8db9-ae9688b076d5
@c58g2000hsc.googlegroups.com>, Or***********@gmail.com says...

[ ... allocating space for scopes inside of a function ]

I know this might vary from one implementation to another, but I just
want an idea how it generally works. I know my understanding is really
rudimentary so any pointers to useful sites or books would be great.

All of the implementation's I've seen allocate a stack frame once when
entering a function, and ensure that enough space is allocated for any
possible path through that function.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[EventHelix.com]

On Jun 24, 5:21*pm, Omari Norman <[e-mail]:

Greetings,

Take for instance the following code:

int main()
{
* * int x=5;
* * if (x == 5)
* * {
* * * * int y = 10;
* * }
* * return 0;

}

Of course x and y are in different scopes. What I am wondering is how
this works at a lower level. For instance, I know that typically
automatic variables are kept on the stack, and that function calls
cause the stack to be pushed down. I read a book that likened the
stack to index cards, with each function call getting its own index
card with its automatic variables.

So what happens when a new scope is entered, as here with the y=10
statement? I would think that the program does not create space for
the y variable when it first starts executing, because it doesn't
"know" whether that scope will ever get entered. So does the program
simply allocate additional room on the same frame in the stack when it
enters the new scope, or does it have to push the stack again to make
room for new variables?

I know this might vary from one implementation to another, but I just
want an idea how it generally works. I know my understanding is really
rudimentary so any pointers to useful sites or books would be great.
Thanks. --Omari

Compilers typically maintain one stack frame per function call.
Multiple scopes will also be managed within the stack frame.

The following link explains stack frames in detail:

http://www.eventhelix.com/RealTimeMa...ranslation.htm

--
http://www.EventHelix.com/EventStudio
Sequence diagram based embedded systems design tool

[Tim Slattery]

Omari Norman <Or***********@gmail.comwrote:

>Greetings,

Take for instance the following code:

int main()
{
int x=5;
if (x == 5)
{
int y = 10;
}
return 0;
}

>So what happens when a new scope is entered, as here with the y=10
statement?

It would be implementation dependent, but IMHO pushing something on
the stack usually involves nothing more than manipulating a pointer.
So the program would push space for y when it enters the if block, and
pop it when it leaves. This would take *very* little time.

--
Tim Slattery
Sl********@bls.gov
http://members.cox.net/slatteryt