Procedures - Programming Languages, Computer Science & Engineering Video Lecture - Computer Science Engineering (CSE)

welcome to lecture 37 so we'll continue
with procedural abstraction so as I said
one thing is that the whole purpose of
abstraction is that you can take any
semantically meaningful syntactic
category and you can use it as a body of
an abstract and an important part of
using it as a body of an abstract is to
give it a name so essentially when
Shakespeare asked what's in a name the
answer should have been an abstract but
yeah he apparently didn't get that so so
you have various kinds of abstracts
expression abstracts which we have
already has actually seen partly
procedural abstracts which are commands
command app stripes and then you have
definition or declaration abstracts as
in modular ml C++ similar small talk etc
right so the most important features of
an abstract are really its name and of
course we have to answer the question
what exactly is an abstract that's an
important semantic issue that we have
not yet addressed and and of course the
parameters to capture similarity of
computations and so on and so forth and
a type checker bool body which is
elaborated whenever the name is so to
speak called with appropriate parameters
right so we were concentrating on
control abstraction and what what I say
for control abstraction me namely
procedures more or less also holds for
these app expression abstracts where the
expression abstracts denote functions
any when we do do the semantics of ml
like functions we will come to that but
let's look at this a form of control
abstraction that we have got
which is basically like functions in
Pascal or procedures which change state
in some fashion and of course when it
comes to these kinds of abstracts
normally there are two kinds of scope
rules that you might use one that we
have been using mostly in languages like
scheme ml and Pascal see ADA Argus 60
most of the most of these languages
actually most of the languages which are
compiled rather than interpreted though
of course are ml environment is an
interpretive environment but most
languages which are compiled prefer to
use a static scoping mechanism which is
which means that which means that is
easier to debug look at non-local
references from the text of the program
rather than from the runtime environment
so the bindings are all compile time or
you the identifiers are all statically
bound so and the the main difference
between and in in the case of dynamic
scoping what it means is that non-local
references as in this case where you
have a chain of calls assuming this
large program P has two procedures p1
and p2 which are at the same level of
nesting and independent of each other
and within P through there is a call to
AB nested procedure p2 one within p2
there is a call to this independent
procedure p1 and within p1 there's a
call to its own nested procedure P 1 1
which has let's say a non-local
reference so if it were a statically
scoped language this non-local reference
would refer to a binding occurrence that
occurs in the innermost
xqe enclosing block
on the other hand in a dynamically
scoped language this reference would
actually depend on this calling sequence
and would refer to the most recent
calling block most recent invocation of
a block which actually contains a
binding occurrence so that would be the
difference between static and dynamic
Lee scoped languages and the reason I
said that dynamic scoping is mostly used
in an interpretive style rather than in
a compiled style is basically this so is
basically because of the runtime
environment so let's let's look at that
let's look at this program executed in
which is which is that same which is
let's say at this point at some control
point here after this chain of calls so
if you look at the runtime stack of this
program runtime runtime I'm not talking
of compile time so if you look at the
runtime stack the activation records
actually look like this so firstly of
course you have you have a global
environment this is sort of normal since
no program usually works without a
global environment you you usually
require some global environment which
contains standard i/o procedures maybe
libraries and so on and so forth so
let's assume that there is a global
environment in which every program
executes and then of course there is
this call to this procedure p1 this
there is this program P which which is
which has a pink border or a purple
border if you like this program P so the
activation record for this program P
which actually well it has a local
declaration of a variable X and it has
of course the procedures p1 and p2
declared locally
so in the process of compiling what
would actually happen is this p1 and p2
would would refer to I mean would refer
to the jump addresses to the cold
segments of the appropriate procedures
okay so so the fact that p1 and p2 are
local to the program P means set in you
have to somehow create a jump address
the address of the code segment and in
case and then and then p1 and take you
could have parameters so in in any call
within p2 p1 and p2 you will have to
type check parameters so so there will
be also part of this would also be some
some information on the kinds of
parameters in the order in which they
appear and their types I mean they're
basically their types so that any call
to p1 or p2 when you are actually
compiling this main program should
should type check right so anyway so the
in the K in the runtime environment this
p1 and p2 would refer mainly to the the
code segments of p1 and p2 where they're
the where the jump addresses are I mean
where the course starts from okay some
so from variant P of course there's a
call to p2 which is this green block and
so gray and so there is an activation
record for p2 p2 1 is of course nested
within p2 within p2 so therefore there
has to be some address to its code
segment and there is a local variable X
and there are of course parameters this
is the main program so it doesn't have
any parameters strictly speaking main
programs also have parameters which
which usually refer to something in the
library routine spec you have like a
Pascal program actually refers to the
files that is going to access but let's
assume that there are no such things so
a procedure usually has some parameters
it has local variables maybe locally
defined procedures whose the address of
whose code segment you require to
maintain and then within from p2 there
is a call to p1 so there is
activation record for p1 which is
similar right and from p1 there is a
call to p1 1 so there has to be an
activation record for p1 1 so the
typical runtime environment at the at
the point when you reach this control
point is that there are 4 activation
records here and the calling chainsaw
length for besides the global
environment so now what happens is this
every time the moment for example you
the moment you stop executing p1 p1 1 4
x3 supposing the execution of p1 1 is
completed then what happens is you are
back in the environment of p1 which
means that the current this is the
current environment pointer ok so you
you have to know at each stage what is
the new environment pointer that you
have to jump to when you exit this scope
during execution so when the scope p1
one is exit exited during execution then
this the stop block the stop blue block
should go and your current environment
pointer should point to the bottom of
this right so the fact that you are
creating a new little environment at
each stage means that you have to have
what is known as a return pointer which
will return you to the current to the
new current environment pointer each
time you exit a block at execution time
during execution the moment the block p1
1 is executed exited you require a
return pointer which gives you the base
address of the previous activation
record ok so this R P is called the
return pointer right and and this
whether your language is and
dynamically scoped language or a
statically scoped language you require
these returned pointers each time right
so so what is called the dynamic chain
which is really the calling sequence
looked at backwards okay you remember
the calling sequence here so this is so
this is really the dynamic chain right
so there is this calling sequence so you
have a dynamic chain which points from P
1 1 to P 1 P 1 to P 2 P 2 to P and P 2
the global environment if necessary but
I have not shown that so essentially you
require this dynamic chain which is
maintained at execution so now in a
language that is interpreted it is
easier to implement a dynamic scoping
mechanism for the present assume that
this is not there in a language that is
dynamically scoped what it means is that
every time you see a full phrase you
translate it and execute it before you
look at the next syntactic phrase okay
so now what happens is supposing you see
this phrase containing this non-local
reference to this blue reference to X
then when you have to translate it you
have to check out whether you have it
you you have you can just Traverse down
the dynamic chain to find out some
reference where find out the first
reference where X was actually declared
or where X has a binding occurrence
since translation and execution both
take place simultaneously at the same
time essentially the most of the basic
information about identifier x' and
there
bindings and so on will still have to be
maintained in a symbol table at runtime
since there is no compile time each
phrase is textually read translated code
is created and executed so whenever you
read a new non-local reference you don't
know anything about it till your travels
down the dynamic chain either you have
it in the current environment or you
have it in the previous environment or
you have it in the previous environment
and whichever is available you just
whichever is the first that comes you
just bind it to that right so under the
dynamic scoping rule or with dynamic
bindings that means all the translation
is done at execution time I mean there
is no separate compilation phase then
what happens is that with just this
dynamic chain this the innermost
enclosing invocation which contains a
declaration of that non-local reference
can be found by just traversing down
this chain and searching through this
through the subsequent activation
records so if you have a non-local
reference what makes it a non-local
reference is just the fact that there is
absolutely nothing corresponding to this
activation record which contains a
Declaration of X or a specification of
its type so what do you do you go
through the previous invocation which is
which is p1 use check whether p1 in the
activations of P in the activation
record of P 1 there is some identifier
with a declaration for X if there isn't
then you just Traverse down from the
return pointer of p1 to the previous
thing and check and you and you will
find maybe this X there is an X replay
here ok remember that all the symbol
table information the identifier name
its type everything is has to be store
since it's interpreted it has to be
stored somewhere at runtime so on
so identifying that it's an idea
a fire with a certain name is possible
at runtime provided you do everything at
runtime in a compiled language
identifiers and names no longer exists
after compilation they have all been
translated into addresses okay so there
is no question of string matching
identifier z' and so on and so forth so
so what in there in a dynamically scoped
environment you just keep traversing
down this dynamic chain in order to find
the most recent binding occurrence that
was encountered in the chain of calls
okay right on the other hand so so this
this dynamic chain actually serves all
this purpose which is the reason early
implementations of Lisp and APL which
wanted to make it interpreter which is
also an easier thing to write actually
use this dynamic scoping mechanism but
what it means textually when debugging a
program is that you cannot look at an
abstract you cannot look at a procedural
abstract in isolation and hope to get
anything out of its non-local references
the only way you can understand that
abstract is by essentially hand
executing and producing the appropriate
calling chain by hand execution and then
determining what would have been that
reference at that point what would have
been the binding occurrence for that
non-local reference at any point yeah so
debugging is interactive debugging may
be easy but a planned debugging of their
text is usually quite hard with with a
dynamic binding mechanism right
so so most languages which which allow
for compilation and ml and scheme
because they actually would like to
encourage debugging from a text they
have they implement what is known as a
static static binding mechanism which
means essentially the kind of binding
mechanism that one sees in pasta right
but then what does this mean this means
that in the runtime environment in the
runtime environment you have to maintain
what happens in a compiled language this
is specific to compiled languages at
compile time a symbol table is created
and an address a relative address
relative to some base for each
identifier is created and what is the
what is a translation of an identifier
let's say of a simple variable an
identifier which denotes a simple
variable
it's just the translation of replacement
of that name by its appropriate relative
address with a reference to the scope in
which it was bound right so which means
that now under so so in the process of
compilation I can actually create a I
can actually create an address for this
with a depth of nesting some let's say
one and a relative address which
basically says that this has been
allocated so much your memory so many
bytes from the top of the base of from
where this cop starts would start in
activation record in the runtime right
at so now any non-local reference X here
would therefore refer to just this
address with it with the appropriate
nesting depth with the same relative
address that it's actually a reference
to this X right so as you read through
as a compiler actually scans
the scans the token file and it
encounters this identifier X it just
hashes on to some binding occurrence and
translates this X by the appropriate
address okay so at the code that is
actually executed only has addresses
relative addresses which at execution
time the basis will be filled up as and
when activation records are created
there will be a base address stored
somewhere which you have seen in your in
the pl0 compiler I mean there is a base
of the stack for the current activation
record and all addresses are relative to
how much above that base should you go
before you reach this variable right so
what all what this also means is that
since you have addresses which are
relative to a base in the case of the
runtime environment you have to maintain
the static structure of the program
somehow I mean you have to maintain for
example the fact that both p1 and p2 are
nested within P so p1 is this red
activation record it has a pointer to
the pink one this green p2 is this green
one which has a pointer to this pink one
and this blue p1 one is nested within p1
so there is a pointer from the blue to
the red to the base of the red so that
now if you can maintain this information
then all non-local references which have
a nesting depth comma relative address
given to them means that you go down the
appropriate chain appropriate this
appropriate chain rather than this chain
I mean you have a current nesting depth
of some let's say 2 and you have a
non-local reference X which you have a
current
sting depth of let's say three p11 is it
nesting depth three and you have a
non-local reference which has been
translated as having nesting depth of
one and has so and so address relative
to that base of that nesting depth one
so which means that you have to traverse
down two steps and go up to the
appropriate translation about the
relative address in order to access X
right so this chain of nesting textual
next nestings is what has to be
maintained in the runtime environment if
you have to have a statically scoped
language implement especially a compiled
language right
so a typical dynamically bar a typical
language with dynamic binding will just
have this kind of will just have a
dynamic chain if it implement static
chair if it implement static binding
then it also has to have a static chain
pointer which gives which essentially
captures the nesting levels and the
nests textual containments of the
various blocks right so so so
essentially the difference is that in a
dynamically scoped language the free or
the non-local identifiers are bound in
the environments of invocations or
calling environments at runtime and of
course dynamic binding is therefore much
more easily implemented in interpreters
you just have to follow the return
pointer chains so this going going back
to this diagram it's just this this SCP
stands for the static chain pointer this
RP stands for the return pointer once
this invocation is over
what is going to be the current
environment pointer or the base of the
what is going to be in a new current
activation record and what is it's going
to be its base address so that you get
from here so essentially when you exit
this block this return pointer the value
in this location is going to be copied
into the current environment pointer and
the value in this is just the address to
this base and so your current
environment pointer will be pointing to
this and all addresses will that you
will be referring to will will refer to
addresses which are either which are
which are anyway less than this so you
don't need to act explicitly
garbage-collected
with further invocations though all the
previous activation records which are
really not supposed to be active but
have been left behind as deadwood will
get over it right you have under either
add under either a static or a dynamic
scoping mechanism when you actually read
p1 you will be actually creating its
code segment somewhere and it's going to
be a pointer to that code segment right
mostly it's going to be a pointer to
that code segment very often if there
are procedures with parameters what
happens is that you often for type
checking purposes you don't want to put
all the information about parameters
basically what you want this type
information and the order of the
parameters right you may not want them
all to be all located here what you
might do instead is have each procedure
since different procedures can have
different numbers of parameters with
different kinds of types what you might
do is you might standardize it to two
pointers you know one is an address to a
code segment another is
a pointer to some place where the
sequence of parameters and their types
and whatever information you might want
to include about their types is
maintained so that you can do the type
checking right so it is some record
which basically allows you to find the
code segment of that procedure if you
want right right so so what it means is
that under a static environment under a
static binding mechanism as you compile
which is normally a compiled language
for a compiled language as you compile
as you read the token string after
lexical analysis basically it's a token
string you actually maintain for each
each block that you have created a
nesting depth it's the the addresses for
each of its variables variables are
going to be translated by addresses
right so the symbol table variables are
going to be translated so the symbol
table contains type information address
size this that such things right so at
compile time you have these symbol
tables for each of these and as you
actually read the program you actually
create all this information that is
essential the moment you exit after
compiling p11 the moment you have exited
p11 this part of the symbol table is no
longer necessary and you work with this
part and you especially when you're
reading the body of p1 right and once
you are finished reading the body of p1
then this part also goes away the next
textual yup available thing is the
procedure p2 so a new symbol table for
p2 is created let's say green in color
and then within p2 there is a procedure
p21 let's say black in color and as you
read p21
you create another symbol table for P
- one the moment you exit p21 the symbol
table for p21 is removed and you are
left with the symbol table for P - the
moment you have finished elaborating
generating the code for p2 which
essentially means you're finished
reading it and generating code Peter
goes away and then you're you're back
with just this which is the main body of
P of the program and you can elaborate
the program and all references in the
program could of course the symbol table
here should also contain should also
contain some information saying that
there are these two procedures p1 and p2
right because in the main body of P you
can have in the main body of P you can
have calls to p1 and p2 which have to be
somehow type checked and similarly in p1
you should have some reference to the
procedure P 1 1 because you can have
hasta p1 in order to hide shaking right
so so and the way you would create
addresses is that at every point in the
symbol table you will actually maintain
what is the current nesting depth that
you are looking at and for each
identifier essentially something the the
current nesting depth is going to be
equal to the length of the static chain
which is going to be maintained at
runtime right so it's just so any
reference to a non-local variable or
even to a local variable will be the
chain position and a relay to address
corresponding to the base of that
activation record right so so this
static pointer chains will have to be
explicitly created and maintained in
order to capture this innermost
textually enclosing block information to
resolve non-local references
to resolve both local and non-local
references it's a uniform it's a uniform
procedure and of course what happens in
the in a dynamic environment is that
sometimes so what it means is that let's
get back to this diagram so what it
means actually let's get back to the
suite of diagrams so now at this so if
you look at the static chain pointer x'
if you look at this there are actually
two different static chain pointer x'
which of course meet at the main program
they are two completely independent one
is this green single pointer chain and
the other is this double pointer chain
right okay so at any point during the
execution of the program the only
references I'm assuming a statically
scoped language the only references you
can have two identifiers are identifiers
in the current activation record
identifiers in the activation record
immediately pointed by the static chain
pointer or identifiers of the activation
record
he pointed down by this by the static
chain pointer of this static chain
pointer you know so what I mean is the
only references you can have in this
blue procedure are to identify as in the
blue procedure in the red procedure or
in the pink procedure you cannot have
any references to identifiers in the
green procedure under a statically bound
condition and a static binding mechanism
okay now you can think of it if you just
generalize this diagram so that you have
lots and lots of procedures p1 p2 p3 p4
p5 all at the same level and all of them
having very deep levels of nesting with
more and more procedures embedded in
them then your runtime stack in some in
when it's executing some piece of code
in the innermost nesting of some
procedure can actually have Oh a whole
lot of pointers a whole lot of static
chain pointer x' which are all
independent except for the fact that
they meet at the main program okay and
at any time at from the top of the stack
in the activation corresponding to the
block which is being executed at any
time the only non-local references are
going so that you actually have a
collection of disjoint chains I mean
they are not disjoint because they all
meet at the main program but otherwise
they are all disjoint so at any point
you actually have a huge you might have
a huge collection of static chain
pointer or static chains which at any
instant only one static chain is really
necessary for your axis in order to
access non-local references okay you
could have a huge number of independent
static chains but at any instant there
is only one static chain that is
actually useful to you for executing
that block right
is it clear when here the example is
that there are two independent static
chains and at this point this is this
static chain is the only thing that is
necessary right if you consider a
nesting mechanism let's if you consider
a nesting mechanism a calling mechanism
for this same program such that you
actually you call you call p2 and then
you call from p2 there is a call to p21
and from p2 one of course there could be
a call to p1 and there could be a call
to p1 one okay then you would have two
independent static chains okay and
depending on which block you are
executing you require only one of the
static chains to be available for that
block that's the only static chain
that's useful for that block the moment
you exit that block you might move into
a different block which is not textually
nested which means you will require a
different static chain pointer right and
in and in languages where there's a huge
amount of side effects like most
imperative languages what it means is
that a lot of people instead of having a
huge number of parameters for their
procedures they tend to use a large
number of Global's okay in that case for
a really complicated program what it
means is that traversing down the static
chains for each and every non-local
reference can become expensive and can
slow down execution right so at any
point what happens is so very often some
speed-up mechanisms are used and one
speed up mechanism is the use of a
display all right so so our display is
just a collection of registers
high-speed registers somehow organized
logically in the form of a stack which
you use in some order okay
and since order of a vast collection of
disjoint static chains at any point you
require only one complete static chain
pointing down up to the main program
these static chain pointer addresses are
all stored in the display in a last in
first out fashion okay so that the
address the base address of the the pink
block will be sturdier and then the base
address of well the green is not
important the base address of the red
one would be stored here and and the
base address of the blue one would be
stored yes
right so as long as you are executing
this blue block these are the only base
addresses you require in order to
resolve non-local references fast okay
you know the nesting level extra next
nesting level here is three if you find
a non-local reference at nesting level
one or some such thing then all you have
to do is look at the base address given
here to down this display stack and look
at the relative address starting from
this base address just imagine if the
stack actually grows and you have a
reference to a global variable at
nesting level 20 that means you'll be
doing 20 hops down the static chain
before you can locate before you can
access that non-local variable and you
don't want to do that 20 hops but you
want that entire procedure or that
function might might have no parameter
is nothing it might just be doing some
tasks which is completely modifying
global variables which means for each
global variable occurrence that is there
either for modifying it or for reading
its value for each of those global
variables you have to make 20 hops down
this static chain
and then find the address and either
modify it or read the value you don't
want to do that it can slow down your
execution tremendously so by the use of
this display what you can actually do is
you can just subtract nesting levels
from the current nesting level go to the
appropriate this go to the display to
find the base address and find the
relative address from that base right so
essentially what we are saying is that
this this pink actually contains the
address of this base address this pink
base this the address of this base is
actually given here similarly the
address of the red base is given here
the address of the blue base is given
here and these are high speed registers
right which which make it which make
accesses fast anyway that's an OP that's
a sort of an optimization or a speed-up
if you like it's nothing more than that
so the act of naming essentially does
this and the which means that what it
means is that in the case of our
dynamically scoped language there are
enough overheads just translating it at
runtime translating the phrases at
runtime and accessing them but you don't
have this extra overhead of a static
chain you just keep following the return
pointers which form the dynamic chain
every time you want to get to resolve a
non-local reference yeah so there is an
extra overhead with static binding but
then that extra overhead means that
debugging your program is easy it's
possible to compile programs use them
for production runs where as an
interpreted programming language
basically means that you will be doing
on the fly not really debugging you will
only be doing on the fly redefining on
the fly development
which may not be systemic which could be
quite ad-hoc so the extra overhead is
worth it provided we can somehow speed
up global accesses and speeding up
global accesses means using some some
some method by which point of hopping
can be saved
somehow by using a fast axis so
supposing you've got a nesting level of
I don't know 60 20 or something you
can't you may not actually have that
many registers but let's assume you have
cash which is a fairly high speed memory
mechanism then you can access the cache
but the point is that you are you are at
a nesting level of 16 you got a global
variable at nesting level of 1 and you
want to find out its address you don't
have to do 16 hops down the static chain
you just have to go to the cache 15
places down at random axis because this
is going to be organized as an array if
you are going to organize it in cash so
it's all going to be this is all just
addresses so they're all uniform right
so you don't have to you can actually
randomly access the corresponding base
address go back to the runtime stack to
that base address and take the relative
address from that so the your access
speeds are substantially improved when
you use a display mechanism and
hopefully your execution will that X at
compile time that X has been translated
into something which gives the nesting
level and relative address from that
from whatever is the current
corresponding base so you have the
nesting level I mean that's what that's
what that's the job you are doing at
compiling while compiling what are you
doing over non-local references you're
replacing all I all identifies by a
nesting level come relative address with
respect to the base
of that block okay so your main problem
at runtime is finding the base of the
block to a relative address is there and
how do you find that their base of the
block it so happens is the difference of
the nesting levels is just going to be
this length of the static chain pointer
the number of hops down the static chain
that you have to perform so instead of
doing that number of hops you actually
organize those that's that static chain
itself as an array in some high speed
memories so that you can randomly access
that you so each time when your static
chain changes there is this extra
overhead then the new static chain will
have to be copied out into this display
right for example here the moment I exit
the moment I exit this tiny block on
exiting this blue block I am not
traveling I am not going back to an
activation record which is along this
same static chain path I am going into
an activation record which belongs to a
different independent static chain so
the extra overhead when I love this when
I exit this blue block and come to this
red block is that I have to completely
erase out my display and now before
executing this red block before
continuing with my execution of this red
block what I have to do is I have to
copy out this static chain into the
display to enable quick accesses to
non-local references in this red block
right in the code segment of this red
block
in each case it's actually oh it could
for example yeah when you go from here
to here it just works out to that but I
can't be I mean but that's not something
you can it can that can really be
guaranteed right I mean you have to at
least do one traversal down this the
appropriate static change fully before
you can decide what to do and it's easy
to do that blindly by just copying out
the display every time you exit the
block and enter a new block so every
time so when I exit this blue block and
come here I look at the static chain
pointer copy it out into the into a
display in a reverse fashion and then
traverse this copy out it's static chain
pointer and so on so yeah that's that's
that's really what I'm going to do but
every time I exit a block and get back
into some previous invocation I have to
do a complete reversal of the static
change at least once but what I am
claiming is that that's all you have to
do right then you can save on subsequent
hops in through a static chain by using
a display right and now of course when
it comes to and the thing is that we
have actually where we are now looking
at pragmatics before semantics because a
lot of the pragmatics is very easy I
mean the act of naming has not
significantly changed implementations
and in the case of recursion it's even
trivial I mean one important thing about
naming I said was to was to provide a
form of abstraction an important feature
of that kind of naming as a form of
abstraction is also that it allows you
to call recursively automatically right
so for example in an unnamed block
except with explicit go-to statements
you can't go back to the beginning of
the block from within the block
with naming you can automatically make
recursive calls and the whole point
about implementations once you have
organized your runtime stack in this
fashion okay
you we should you should throw your mind
back to the right the runtime
environment in languages like Pascal and
ml as opposed to runtime environments in
languages like Fortran okay in so just
just briefly recalling what we did in
Fortran in Fortran every block was
independent of each other and they were
all statically allocated in memory okay
and they were they all contained
persistent data and any reference was
had an absolute static address okay and
one consequence of that so for example
if you were to take our diagram enough
enough
you know Fortran like environment with
static allocation what it means is that
there there is going to be a pink block
code segment come data separate from I
have forgotten the color of p1 or red P
one is going to be code segment and data
P to the question of nesting of course
never arose so let's assume p1 1 and P 2
1 don't exist ok
p2 would have code segment and data and
they would all be fixed for life and by
life I'm in the lifetime of the program
right so what it meant was that all
references whether local or non-local
would have a fixed absolute address
which is related to the address given at
loading time of the program relative to
some base given at loading time of the
program so what that means is that you
can't have recursive calls because
recursive calls me
having different copies of the same
activation record with different values
and so on and so forth so you just can't
have a question on the other hand with
the kind of runtime stack environment
but what but on the flip side of the
coin is that it's also very fast having
fixed at all Fortran programs executes
extremely fast because they don't have
these complications of allocating fresh
at runtime deallocating
traversing pointers none on there no
none of these hazards
so the executions are very very fast one
reason why scientific programs are still
written in Fortran the other important
reason of course is that lots of them
were written in Fortran and nobody want
to know if the people are feeling too
lazy to change it ok but the but the
moment you allow for recursion at the
moment you have organized your runtime
environment as the form of a stack with
a dynamic allocation of memory of
activation records and so on and so
forth you directly open up and make it
flexible for the purpose of implementing
requests so what it means now is if
there is a recursive call so let's if
there is a recursive call you have this
program here and then there is another
sub program here which is which is
recursive then what it means is that
your activation record would look like
would really look like something like
this for over n calls over n calls to
this this subroutine what you will have
is essentially one activation record for
well here are the Global's let's say the
global environment you'll have one
activation record for the main program
which with with a return pointer well
know the main program so there are no
return pointers in no static chain
pointer and then you have several
activations of this recursive call with
a static chain pointer pointing here
return pointer pointing here and then
let's say there are three activations of
this three at you assuming the casement
the recursion has been called thrice
then you will just duplicate the static
pointers like this and your return
pointers will be like this so you can
have several incarnations of the
variables local references will be
locally resolved non-local references
will go down the static chain when you
exit one invocation you automatically
have from the return pointer the address
of the next or variable to the
invocation that you are returned to
right and so there is absolutely no
problem with the implementation of
recursion in this case of course then
the next more the next important
question is what exactly do we mean by
meanings when you have functions and
we'll worry about that next