Вы находитесь на странице: 1из 367

##################;###

################################################

#####
################## ###
#######
############################################################################## ###!
###"#######$###%###&###'###(###)###*###+###,###-
###.###/###0###1###2###3###4###5###6###7###8###9###:###;###<###=###>###?
###@###A###B###C###D###E###F###G###H###I###J###K###L###M###N###O###P###Q###R###S###
T###U###V###W###X###Y###Z###[###\###]###^###_###`###a###b###c###d###e###f###g###h##
#i###j###k###l###m###n###o###p###q###r###s###t###u###v###w###x###y###z###{###|
###}###~#########R#o#o#t#
#E#n#t#r#y#################################################################
################*w7R####
######P#P#4#0#########################################################
###########################################1[########S#u#m#m#a#r#y#I#n#
f#o#r#m#a#t#i#o#n###########################(##############################
##################
######C#u#r#r#e#n#t#
#U#s#e#r###############################################################
##################)#######@#
##############################################################
##############################################################
###################################

#####E#####1#1[##f###(###(###y###[############################
#######################################
###
###
#####
#####################
######################################
##########################################################################
ratPri
n;
##
###
###
###
:=)
Gite
fin
new
to
).G

al;#e
pou

Scory
|
#
n
D2#
#
#d#####
########
t
iici
##############
Un############## a
####o(x
###
#d#
######
|

KTC
ID$
rJeApr
######## F-
#####us#
#####;*.#####
cs
PDI
####Fre##############
#######HW####################
rd
####OFF#
##PDI
###
######
PDI
###
H3#rd
#####################################################OFF############
############################################
###
######
PDI
###
HW#an
cOFF
###
###
e?.
m
prmin
e
d#d#
###
########################################################
#
st######################################################are
nes
d.
#
###'##@##'#####5(#####5(####5(##&##)##"##)#####)##@###*#####U*####
#U*##T##U*##&##,##"##,#####,##@## -#####I-#####I-##>##I-
##&##/##"##/#####/##@##/#####'0#####'0####'0##&###3##"##53#####W3##@
##o3#####3#####3#####3##&##5##"##5#####5##@###6#####Q6#####Q6####
Q6##&##/8##"##U8#####w8##@##8#####8#####8##L##8##&###;##"##A;#####c;#
###{;#####;#####;#####;##&###@##"##'@#####I@##@##a@#####@#####@##`#
#@##&###C##"##'C#####IC####aC#####C#####C#####C##&##F##"##

G#####+G##@##CG#####G#####G##N##G##&##I##"##I######J##@##1J#####qJ##
###qJ##z##qJ##&##K##"###L#####3L####KL#####L#####L####L##&##O##"##
O#####O##@##O#####1P#####1P##&##1P##&##WR##"##}R#####R##@##R#####S
#####S####S##&##U##"###V#####3V##@##KV#####V#####V##z##V##&###Z##"
##+Z#####MZ#####eZ#####e[#####e[####e[##&##^##"##!
_#####C_####[_#####;a#####;a##.##;a##&##ic##"##c#####c##@##c#####
d##### d##N##
d##&##Wg##"##}g#####g####g#####wi#####wi####wi##&##?
k##"##ek#####k##@##k#####k#####k####k##&##cm##"##m#####m##@##m##
####n######n##>###n##&##Aq##"##gq#####q####q#####as#####as#####as##&##
uu##"##u#####u##@##u######v######v##^###v##&##sx##"##x#####x##@##x
######y######y#####y##&##z##"##z######{##@##1{#####q{#####q{##2##q{##&
##}##"##}#####}##@###~#####C~#####C~####C~##&##

##"##/#####Q##@##i################&##s##"#########@#####
################&##  ##### 
#####?##@##'###### ##"##
##8## ##&####"##
#######@########W#####W##*##W##&####"######
###@#######!#####!####!
##&####"##########@##1#####q#####q####q##&##;##"##a#######@#
#################&####"#########@#######!#####!#####!
##&##?
##"##e############################&#####"##=#####_##@##w##
##########X####&#####"##5#####W####o##############H#####&##
W##"##}#######@##################&####"##########@##'#####
g#####g##n##g##&####"##########@##5#####u#####u##@##u##&####
"#########@########U#####U####U##&##'##"##M#####o##@#######
#######N####&#####"##;#####]####u###################&#####"##
-
#####O####g################&####"#########@#######;##
###;####;##&####"##########@##/#####o#####o####o##&####"##
!#####C##@##[############>####&####"#######!##
##9#####Y#####Y##`##Y##&####"#########################N##
##&#####"##-
#####O##@##g################&##{##"#########
##############r####&##m##"#########@################
##&####"########)##@##A#################&####"#########
`#######S#####S#####S##&##S##"##y#######@################
##&####"##########@########[#####[#####[##&##c###"#########
##@#########################&##
##"##
#####
## #########!######!#### #!
###&##=###"##c#########@######################&#####"###########
@########/######/###j##/###&#####"###########@########9######9#####
9###&## ##"###!#####?!#####W!#####W%#####W%####W%##&##?-##"##e-#####-
##@##-#####-#####-####-
##&##0##"###1######1####;1#####1#####1####1##&##4##"##4#####4##@
##4#####75#####75##d##75##&##7##"##7#####7##@##7#####;8#####;8####
;8##&##:##"###;#####-;##@##E;#####;#####;####;##&##s>##"##>#####>#
#@##>######?######?##8###?##&##KA##"##qA##`##A#####E##### F####!
F######G######G#####G##&##I##`###J#####oJ#####J####J##&##GL##"##mL##
###L## ##L#####L#####L####L##&##uM##"##M#####M##
##M#####M######N#####N##&##N##"##N#####N#####N#####
O#####'O#####AO#####[O#####uO#####O##6##O##h##O##H##GP##v##P##v###Q##
$##{Q#####Q##"##U####U####yX##2##iZ####Z##############
#########AGp0 ################/D# A
##p################w>#######Al######r####MV
#########d######0##Z#########!###Programming Languages I:#ALGOL 60X
#!#########!##### ###########!#########!
#####d######0##Z#########2####Z=##S#########@#d######0##Z#########'#
##Instructor: Matthew SmosnaJune 4, 1996R
#'#########################
#################'#############@##d######0##Z#######
###@##d######0##Z#########################wh####m, n
a########L#w>##############E####I#####################
#########AG0###############
# # A0|################|
#B###############r####j#o########A#d#########Z#############ALGOL#
#################
#############################d#########Z#########2####j##
#########d#########Z############Designed in 1958, 1960Goal: Universal
Programming Language... for describing algorithms in publications... for
programming algorithmsIt generalized the structures in FORTRAN.
##########>###############M###############)##############################A##d#
########Z#######'###A##d#########Z#######.###A##d#########Z###########A##d
#########Z#######)###A##d#########Z################################?y# ###
###l#w>####
#####################################
#########AG0###############
# # A0|################|
#B###############r####j#o########A#d#########Z#############ALGOL
(contd)
#################
#############################d#########Z#########2####j##
#########d#########Z#########z###Characterized by a hierarchical structure:
Nestingstatementscontrol structuresscoping rulesThe last was a big advance!
#z#########3###############,#################################z#########+###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z################################?
T#########d#D##########################################
#########AG0###############$#WD# A0|################|
#B#######mn######r####j#o########A#d#########Z#############Structural
organization#
#################
#############################d#########Z#########2####j##
#########d#########Z############Declarative & Imperative Statements... like
any imperative languagePrimitive declarations:integer i,j,k;real a,b,c;boolean
m,n;Array declarations:integer array l[-5:5]:
##########$###############!
###############################+##################################################
########$###A##
#d#########Z#######!###A##
#d#########Z###########A##
#d#########Z###########@##
#d#########Z###########@##
#d#########Z##########@##
#d#########Z###########A##
#d#########Z###########@##
#d#########Z################################?
T##########7D##########################################
#########AG0###############$#WD# A0|################|
#B###############r####j#o########A#d#########Z######### ###Structural
organization (contd)
# ######### ##### ########### #########
#######d#########Z#########2####j##
#########d#########Z############Functions & proceduresinteger procedure foo
(x,y);# integer x,y;# foo := x+y;procedure bar (x,y);# integer x,y;# x:= x+y;#
##########################:###############.###
##########################A##
#d#########Z#######:###@##
#d#########Z#######.###@##
#d#########Z####### ########################?t#########<#
####!#####################################
#########AG0###############$#WD# A0|################|
#B###############r####j#o########A#d#########Z#############Imperative
statementse
#################
#############################d#########Z#########2####j##
#########d#########Z#########9###Assignments & control flowNo I/O!Assignments
a := b + cj
#9#########################################
###############
#################9#############A##
#d#########Z###########A##
#d#########Z#######
###A##
#d#########Z#######
###@##
#d#########Z#######'###$#######################%###&####D####(###############
#####################
#########AG0###############$#WD# A0|################|
#B###############r####j#o########A#d#########Z#############Imperative
statements (contd)
#################
#############################d#########Z#########2####j##
#########d#########Z############Control structures:if a = b then# a := a *
z#else# a := a / z;Compare to FORTRAN: IF (A.EQ.B) GOTO 20# A = A/Z#
GOTO 30#20 A = A * Z#30 ...
##########################.###############################J######################
########A##
#d#########Z#######.###@##
#d#########Z###########A##
#d#########Z#######J###@##
#d#########Z#######.###+#############?#####9
#,###-###,
7D*###/#####################################
#########AG0###############M# A0|################|
#'<C#################@#`########A
###############'<###p##########9#####^
##########d#########d#########3###Algols for can get
complex;#powerful but baroque#
#3#########################################(#################3#########3#######d#
########d#########r####j#o #########d#########Z#############Definite
iteration
#################
#############################d#########Z#########2####j##########@#d
#########Z#########<###Definite Iteration:for i := 1 step 5 until 100 do# x := x +
5;Indefinite iteration:for newguess := improve(oldguess)# while abs(newguess -
oldguess) > 0.001 do# oldguess := newguess;Compare to FORTRAN:10 CALL
IMPROVE(NEWGUESS,ONE)# IF (ABS(OLD-NEW).GT.0.001)GOTO 20# OLD = NEW#
GOTO 10#20 ...
#<#########################-
###############################f###############################k#################<#
############A##
#d#########Z#######-###@##
#d#########Z###########A##
#d#########Z#######f###@##
#d#########Z###########A##
#d#########Z#######k###@##
#d#########Z#######5###2####################?4#3###4####7D1###6###############
#####################
#########AG0################9# A0|################|
#B###############r####j#o########A#d#########Z#############Algol and
the GOTO
################# #############################d#########Z#####
###2####j## #########d#########Z#####
######Algol also has a goto statementbut it is more or less unnecessaryThe if, for
and for-while are sufficient for almost everything!... and they are equivalent to
the Universal Turing Machine.p
##########
###############################@###############<########################## ###A##
#d#########Z###########A##
#d#########Z#######@###A##
#d#########Z#######<###A##
#d#########Z#######<###9#########################:###;###D
7D8###=###############
#####################
#########AG0###############$#WD# A0|################|
#BP###P`########################u###############WD###v##########9##
##X##########d#########d#########;###combines several statementsinto a
single unit or structurey
#;#########;#################;#################d#########d###############d#####
####d#########r####j#o########A#d#########Z#############Compound
Statementso
################# #############################d#########Z#####
###2####j## #########d#########Z############Algol also provides
compound statements:begin# s1;# s2;# ...# sn;#end;Anywhere you can use a single
statement you can use a compound statement.#
##############################################################
###########I##########################)###A##
#d#########Z###########@##
#d#########Z#######I###A##
#d#########Z#######C###@#########################A###B####w>?###D###############
#####################
#########AG0###############$#WD# A0|################|
#B###############r####j#o########A#d#########Z#############Compound
statements (contd)
#################
#############################d#########Z#########2####j##
#########d#########Z#####
######Example:if (a = b) then#begin# a := a * z;# b := b - 1;#end#else ...
Another example:procedure foo(x, y);# integer x, y;#begin# y := y + 1;# x := x +
y;#end;
########## ###############?### ###########################K###
###################### ###A##
#d#########Z#######?###@##
#d#########Z###########A##
#d#########Z#######K###@##
#d#########Z#######J###G#####################
###H###I###T#w>F###K#####################################
#########AG0###############M# A0|
##################'<###############r####j#o
#########d#########Z#############Compound statements (contd)
################# #############################d#########Z#####
###2####j##########A#d#########Z#########T###Principle: Provide a
means to construct complex structures out of simple structures.
#T#########T#################T#########T###A##
#d#########Z#######Q###N#########################O###P###|
#w>M###R#####################################
#########AG0###############$#WD# A0|################|
#BP##########################!###############|

WD###x##########9#####>J###########d#########d#########7###control
structures may containother control structures#
#7#########7#################7#################d#########d###############d#####
####d#########r####j#o########A#d#########Z#############Nesting Control
Structures
################# #############################d#########Z########2####j##
#########d#########Z#########w###Example:begin# a := 1;# if (...) then#
for ...# begin# ...# end# else# ...#end;This lead to ...#
#w######### ###############^### #############################w#########
###A##
#d#########Z#######^###@##
#d#########Z###########A##
#d#########Z#######X###U#########################V###W####7DT###Y#################
####################
#########AG0###############M# A0|
################D#I###############r####j#o
#########d#########Z#############Structured programming!
#################
#############################d#########Z#########2####j##########A#d
#########Z############Structured programming:Programming using control structures
that reflect the computation. It includes:Nesting (hierarchical structures)no (or
minimal) GOTOso
########################################################A##
#d#########Z#######P###A##
#d#########Z#######"###A##
#d#########Z###########A##
#d#########Z#######_###\#########################]###^###
D[###`#####################################
#########AG0###############$#WD# A0|################|
#B############################################################

###P##########################P#########################P##########
################P###P####################P#########################P#####P
#####################################r####j#o########A#d#########Z###
##########Nested procedures.
#################
#############################d#########Z#########2####j##
#########d#########Z############In Algol you can also nest procedure
definitions:procedure foo(x, y);# integer x, y;#begin# integer procedure bar(z)#
integer z;# bar := x + z;#x := bar(y);#end;##
##########2###############y### ######################2###A##
#d#########Z#######y###@##
#d#########Z#######f###c###
#####################d###e####
Db###g#####################################
#########AG0###############L#WD# A0|################|
#B###############r####j#o########A#d#########Z#############Nested
procedures (contd)
#################
#############################d#########Z#########2####j##
#########d#########Z#########2###Question: What names are visible where?
Determined by the scoping rules.Algol uses static scoping ...more on this later...
Definition: Scope:Scope: that part of a program in which a variable is visible.In
Algol, this is determined by block structure.Block = compound statement or
procedure definition.
#2#########(###############,#######################################################
########o###############3#################2#########(###A##
#d#########Z#######!###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######>###A##
#d#########Z#######1###A##
#d#########Z#######3###A##
#d#########Z#######m###j#########################k###l####Di###n#################
####################
#########AG0###############$#WD# A0|################|
#B################################P###P##P#######################&##E######
#########WDP#######################P#########################P#####
#########################d##########9#P##`#O#(##########d#########d##
###########Defines scope ofdeclared variablese
###############################################d#########d###############d#####
####d#########r####j#o########A#d#########Z#############Nested
procedures (contd)
#################
#############################d#########Z#########2####j##
#########d#########Z############Block structure:begin# delcarations#
statements#endAll names declared in a block are visible only inside the blockThe
block defines the scope of the variables in the block.Blocks may be nested.Inner
blocks inherit bindings from outer blocks.
##########################&###
###########@#############################################A##
#d#########Z#######&###@##
#d#########Z#######@###A##
#d#########Z#######;###A##
#d#########Z###########A##
#d#########Z#######0###A##
#d#########Z#######t###q#########################r###s###<
w>p###u#####################################
#########AG0###############$#WD# A0|################|
#B########################################################
#######A###P#C###########################################
#######P### 0####################P###00#####################P###0#
#####################P### ## #####################P####
########################P############################P#####P#################
####P###P#Pp#####################P###Pp##p####################################
r####j#o########@#d#########Z#############Exampleu
#################
#############################d#########Z#########2####j##
#########d#########Z#############begin# real x, y;# real procedure
cosh(x);# real x;# cosh := exp(x) + exp(-x)/2# procedure f(y, z);#
integer y, z;# begin# real array A[1:10]# A[y] := z; ...# end;#
begin# integer array count[0:99]# count[1] := x;# end;# f(3,4); y :=
cosh(x);#end;
############### ###########################@##
#d#########Z#######{###x#####################
###y###z####Dw###|#####################################
#########AG0################?# A0|################|
#B###############r####j#o########A#d#########Z#############Advantages
to block structurev
#################
#############################d#########Z#########2####j##
#########d#########Z############Nice hierarchical way of organizing names
Nested blocksEasy way to share variables between proceduresnested procedures &
blocks.Easy to hide namesdisjoint blocks.No global subroutine namesunless desired.#
######
###*###############################/###############################################
##################################################################################
#########*###A##
#d#########Z###########A##
#d#########Z#######/###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#########################################<#7D~###################
#####################
#########AG0###############M# A0|
################T#'<###########################################################
#
##################################P###
####################P########################P####
#####################P###@#P@#####################P###P@#P
#####################P###P #
#####################P###@P@####################P###P@P####################
#P###P#####################################r####j#o
#########d#########Z#############Example#
#################
#############################d#########Z#########2####j##########@#d
#########Z############Example:begin# integer m;# procedure P(l)# integer l;#
begin# m := l;# end;# begin# integer m;# P(1);# end;#end;#
########## ################## ###################### ###A##
#d#########Z##########@##
#d#########Z#########################################,#7D####################
####################
#########AG0###############
## # A0|################|
#B###############r####j#o########A#d#########Z#############Example
(contd)
#################
#############################d#########Z#########2####j##
#########d#########Z#########-###Question: Which m gets changed?Answer: ???
s
#-###########################################################-#########"###A##
#d#########Z###########A##
#d#########Z##########################################D####################
####################
#########AG0###############
c# A0|################|
#B#######)c######r####j#o########A#d#########Z#############Static vs.
dynamic scoping
#################
#############################d#########Z#########2####j##
#########d#########Z#############Static scoping: procedure is
called/evaluated in the environment of its definition.Look at the block in which it
was defined!Dynamic scoping: procedure is called/evaluated in the environment of
its caller.Look at the block where it is called.Only older versions of LISP are
not.
#######
###################:###############
###############################+###############################B###############&###
########################################################T###A##
#d#########Z#######+###A##
#d#########Z#######Q###A##
#d#########Z#######&###A##
#d#########Z#######$###A##
#d#########Z##########################################D####################
####################
#########AG0################# # A0|################|
#B############################################################
###############################
###P####P#####################P###P#P`#####################P###P`#p`#####
################P###@#P@#####################P###P@#P#####################P##
#P######################P###PPP####################P###P`###########
##########P###`#P`####################################r####j#o########A
#d#########Z#############Quiz
#################
#############################d#########Z#########2####j##
#########d#########Z############Consider the following Algol code:BEGIN#
integer x;# PROCEDURE foo(y);# integer y;# y := x;## x := 6;# BEGIN#
integer x,y,z;# x := 5;# y := 4;# foo(z);# print(z,y);# END;#END;
##########!################################## ##########################A##
#d#########Z###############d#########Z#######################O#############
## D########################################
#########AG0#################WD# A0|################|
#B###############r####j#o########A#d#########Z############Quiz
(contd)u
############### ###########################d#########Z#########2####j##
#########d#########Z############Question: In static scoping, what is the
result?Answer: 6, 4Question: What would be the answer in dynamic scoping?Answer: 5,
4
##########################)#######################################################
########/##########################################################1###A##
#d#########Z##########A##
#d#########Z#######7###A##
#d#########Z#######
###A##
#d#########Z######################################
w>########################################
#########AG0###############
c# A0|################|
#B#######mt######r####j#o########A#d#########Z############Quiz
(contd)
############### ###########################d#########Z#########2####j##
#########d#########Z#########y###How about:begin## procedure foo(y);#
integer y;# y := x;##begin# integer x, y;# x := 3;# foo(y);# print(y);#end;#;
#y#########################n### #############y#############A##
#d#########Z#######n########d#########Z#####################################
###WC########################################
#########AG0###############
c# A0|################|
#B#######mt######r####j#o########A#d#########Z############Quiz
(contd)#
############### ###########################d#########Z#########2####j##
#########d#########Z#########^###Question:In dynamic scoping?Answer: 3
Question:In static scoping?Answer: x is undefined.
#^#########
###############################
###############,#################^#########
###A##
#d#########Z###########A##
#d#########Z#######
###A##
#d#########Z#######
###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########################################w>####################
####################
#########AG0################c# A0|################|
#B#######mt######r####j#o########A#d#########Z#############Static
scoping
#################
#############################d#########Z#########2####j##
#########d#########Z#############Almost all languages are statically scoped.
Only old LISP is not.Advantages:Readability: The effect of a function can be
determined by looking at its definition.Modularity: When calling a function you
dont have to worry about name conflicts with your variables.
###########,###############################
##########################################,###A##
#d#########Z###########A##
#d#########Z#######
###A##
#d#########Z#######V###A##
#d#########Z#######h###A##
#d#########Z#########################################|
#D########################################
#########AG0###############D
9# A0|################|
#B#######ao######r####j#o########A#d#########Z#############Examplen
#################
#############################d#########Z#########2####j##
#########d#########Z#########`###Example:begin# integer x;# x := 6;#
foo(5);# print(x);#end;Foo cannot change value of x!
#`######### ###############8### #############################`#########
###A##
#d#########Z#######8########d#########Z###########A##
#d#########Z##########################################7D####################
####################
#########AG0###############L#
# A0|################|
#B###############r####j#o########A#d#########Z#############Principles
:
#################
#############################d#########Z#########2####j##
#########d#########Z############The behavior of a construct should be able
to be determined by looking at its definition.Users should be protected from
unexpected changes to variables.#
####################################Z###A##
#d#########Z#######?###A##
#d#########Z#########################################t#D##################
#####################
#########AG0#################
# A0|################|
#B###############r####j#o########A#d#########Z#############Static vs.
dynamic scoping
#################
#############################d#########Z#########2####j##
#########d#########Z############We think better statically (and not
dynamically).Master static relationsNot dynamic relationsSo, make dynamic behavior
of a program look like its structure.#
##########2###############.###############?##########################2###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######?###A##
#d#########Z#########################################L#D##################!
#####################
#########AG0###############\#
# A0|################|
#B###############r####j#o########A#d#########Z#############Static vs.
dynamic scoping (contd)o
#################
#############################d#########Z#########2####j##
#########d#########Z##### ### ###When reasoning, we want to be able to
describe the sttae of computation at each point in program.What happenned up to
now?(1) If your program contains:Only assignment statements:x := 1;#a := x *
y;#...#c := a + b;#x := a + cCan tell what happenned using a pointer to a
statement?
# #########b###############################################################/###
###########9################# #########b###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######/###@##
#d#########Z#######9###A##
#d#########Z#########################################
D##################"#####################
#########AG0################
c# A0|################|
#B###############r####j#o########A#d#########Z#############Static vs.
dynamic scoping (contd)p
################# #############################d#########Z#####
###2####j## #########d#########Z#####!######Even with conditionals,
just point into the program and you can tell what happenned.(2) Assignments &
Procedures:Need to know:Point in procedure bodyWhere the procedure was calledYou
end up with a sequence of textual indices.
##########s###############s##########################U###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######.###A##
#d#########Z##########################################/D####################
####################
#########AG0################
c# A0|################|
#B###############r####j#o########A#d#########Z#############Static vs.
dynamic scoping (contd)e
################# #############################d#########Z#####!
###2####j## #########d#########Z#####"######(3) While loops. Need:
Textual Index for place in loopDynamic index counts # of times through the
loop.Since you have nesting of loops, you may need a textual index and a sequence
of dynamic indices.No matter how the program was written, these indices provide an
independent representation of the progress of the computation.If GOTO is used
poorly (spaghetti) it is hard to describe the state of the program in a meaningful
way!record every statement executed (unhelpful!)k
########################################################A##
#d#########Z#######"###A##
#d#########Z#######4###A##
#d#########Z#######a###A##
#d#########Z##########A##
#d#########Z#######h###A##
#d#########Z#######,###A##
#d#########Z#########################################
D##################$#####################
#########AG0################
# A0|################|
#B###############r####j#o########A#d#########Z#############Static vs.
dynamic scoping (contd)e
#################
#############################d#########Z#####"###2####j##
#########d#########Z############Conclusion: GOTO is too primitiveinvitation
to make a mess of ones program.What if GOTO is used intelligently?Could be
replaced by structures in any case.Will look like while or for or if-then-
else.#
##########"###############.###############&###############a######################
####"###A##
#d#########Z#######.###A##
#d#########Z#######&###A##
#d#########Z#######/###A##
#d#########Z#######2###A##
#d#########Z##########################################7D##################
%#####################
#########AG0#################O# A0|################|
#B###############r####j#o########A#d#########Z#############Parameter
passingO
#################
#############################d#########Z#########2####j##
#########d#########Z#####$###*###FORTRAN used pass by referenceAlgol uses
pass-by-name and pass-by-value.Pass-by-value: The value of the arguement is passed.
The value of the argument cannot be modified ...... even if the formal parameter is
assigned.Pass-by-value is inefficient for arrays ...... because it forces copying.
#*#########L##############################,#################################*#####
####!###A##
#d#########Z#######+###A##
#d#########Z#######5###A##
#d#########Z#######1###A##
#d#########Z#######.###A##
#d#########Z#######,###A##
#d#########Z###########A##
#d#########Z##########################################WC##################&#
####################
#########AG0#################O# A0|################|
#BC###`#0#############@#########b#%###############L
W###Z##########9#0###(#############d#########d#########+###Value
parameters mustbe declared in Algol.#
#+#########+#################+#################d#########d###############d#####
####d#########r####j#o########A#d#########Z#############Examplep
#################
#############################d#########Z#####$###2####j##
#########d#########Z#####%###D###Example:procedure foo(n);# value n; integer
n;# ...# ##The default (in Algol) is pass-by-name.Pass-by-name: The name of the
argument is substituted for the format parameter in the procedure.When the formal
parameter is referenced, it expands into the argument expression.Logically, not
actually implement this way.
#D######### ###############3###

###########(###############c###############R###############+#################D#####
#### ###A##
#d#########Z#######3########d#########Z#######(###A##
#d#########Z#######c###A##
#d#########Z#######R###A##
#d#########Z#######+###A##
#d#########Z#########################################D
7D##################'#####################
#########AG0###############M# A0|
################L#I###6G#################
#M#######################MC###p##`###############`####C###0P#`###########
####`#######6#G#################'<######o###############D#IC#######
##############`####C###PP#################`##################9#p##p
############d#########d#############Call-by-reference#a = 2#b = 5b
###############################################d#########d#########9#p######
##########d#########d#############Call-by-name#a = 2#b = 5
###############################################d#########d#########9# ###p#
############d#########d######### ###Call-by-reference#C[1] = 2#i = 2
# ######### ################# ######### #######d#########d#########9#
#######R###########d#########d#########$###Call-by-name#C[1] = 0#i =
2#C[2] = 2
#$#########$#################$#########$#######d#########d#########r####j#o
#########d#########Z#############Exampler
################# #############################d#########Z#####
%###2####j############d#########Z############Consider:procedure
bif(x, y);# integer x, y;#begin# y := y + 1;# x := 2;#end;#...#a := 3;#b :=
4;#bif(a,b);#...#integer array C[5];#i := 1;#C[i] := 0;#bif(C[i],i);##
##########
################## ######################
###A##
#d#########Z###############d#########Z##############
#
###############
#########4#7D###################(#####################
#########AG0###############L#gE# A0|################|
#B####################

g=P##############################6###################Wz#########z#####9#
0###@############d#########d#############...#foo(a * b)#...
###############

###############################d#########d#########9#`###p#############
d#########d#########A###Thunk is created that,when executed, returns#the value of
a * b.,
#A#########A#################A#################d#########d#######*#######d#####
####d#########r####j#o########A#d#########Z#############Implementing
pass-by-name#
#################
#############################d#########Z#####&###2####j##
#########d#########Z#####'######How is pass-by-name implemented?Real copying
(of text) is too expensive.A thunk is passed!Thunk: a parameterless procedure
(code + environment).When a formal parameter is refenced the thunk is executed to
return the right value of location.
##########!###############+###############################
###############9###############`##########################!###A##
#d#########Z#######)###A##
#d#########Z###########A##
#d#########Z#######9###A##
#d#########Z#######`###A##
#d#########Z###############################################D####################)#
####################
#########AG0#################Y# A0|################|
#B###############r####j#o########A#d#########Z#############Quiz
#################
#############################d#########Z#####'###2####j##
#########d#########Z#####(######Question: What happens here?procedure
foo(x);# integer x;#begin# integer i;# i := 1;# x := 5;#end;#...#begin#
integer i; integer array A[10];# i := 0;# A[i] := 1;# foo(A[i]);#end;Answer:A[0]
= 5; i = 0Why? Answer: static scoping.
#############################################

##################################################################################
########A##
#d#########Z###############d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#####################################
###### 7D
###################*#####################
#########AG0###############LE# A0|################|
#B###############r####j#o########A#d#########Z#############Back to
Algol...
#################
#############################d#########Z#####(###2####j##
#########d#########Z#####)######Biggest advances over FORTRAN were:
Structured programsRecursionBut iteration and recursion are just as powerful
Universal Turing Machines (Turing Machines have only iteration)
##########$###############################3###############?
##########################$###A##
#d#########Z###########A##
#d#########Z#######
###A##
#d#########Z#######3###A##
#d#########Z#######?###A##
#d#########Z##############################################/D####################+#
####################
#########AG0###############D#GF# A0|################|
#B#######Al######r####j#o########A#d#########Z#########
###Recursiono
# ######### ##### ########### #########
#######d#########Z#####)###2####j##
#########d#########Z#####*######Why is recursion an advantage?Some functions
are naturally expressed recursively.For example:factorial = n! = 1 * 2 * ... * nA
better way of expressing this is:0! = 1#n! = n x (n-1)!or ...fac(n) = if n = 0 then
1# else n x fac(n-1)
##########################4############################## ### ###########
%################### ###########################5###
##########################A##
#d#########Z#######4###A##
#d#########Z##########A##
#d#########Z#######!###A##
#d#########Z#######$###A##
#d#########Z###########@##
#d#########Z###########A##
#d#########Z#######5###@##
#d#########Z##############################################/D####################,#
####################
#########AG0###############4#GF# A0|################|
#B#######m#######r####j#o########A#d#########Z#############Recursion
(contd)
#################
#############################d#########Z#####*###2####j##
#########d#########Z#####+#######But this is easy to program using iteration!
fac := 1#for i := 1 to n# fac := fac * i;Not all fuctions are so easy to do
iteratively!Ackermanns function:Ack(m, n) = # if (m=0) then n+ 1# else if (n= 0)
then# Ack(m-1, 1)# else# Ack(m-1, Ack(m, n-1))
###########-###############+### ###########0###############################h###
#######################-###A##
#d#########Z#######+###@##
#d#########Z#######0###A##
#d#########Z###########A##
#d#########Z#######h###@##
#d#########Z########### ###################D##H##!###"#####/D####$###############-
#####################
#########AG0###############?H# A0|################|
#B###############r####j#o########A#d#########Z#############Recursion
(contd)
#################
#############################d#########Z#####+###2####j##
#########d#########Z#####,###v###Fac:Singly recursive (one recursive call).
Can use accumulator in iteration.Ack:Doubly recursive (Z calls):Hard!
#v#########################K###############################!
#################v#############A##
#d#########Z#######'###A##
#d#########Z#######$###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######*###'#########################(###)####/D&###+###############.#
####################
#########AG0###############t#?H# A0|################|
#B###################\#?
H###&####################D###################4#DI#####P###########
########I###`#######################I######p###################P####0###
###################I###p#P#####################I#####P#P###################I#
##`#0#####################I###0####################################9#@###
#Xk###########d#########d#############CP
###############################################d#########d#########9#@###`###k#
##########d#########d#############A
###############################################d#########d#########9#@#####xk#
##########d#########d#############Bi
###############################################d#########d#########r####j#o
########A#d#########Z#############Recursion (contd)
#################
#############################d#########Z#####,###2####j##
#########d#########Z#####-######Some problems are naturally solved
recursively:Towers of Hanoi:######Problem: Move disks from A to B one at a time
without placing a larger disk on a smaller disk.Hard to solve iteratively!
##########2###############################################X#######################
###################2###A##
#d#########Z###########A##
#d#########Z#######_###A##
#d#########Z###########A##
#d#########Z#######1###.#######################/###0###l#/D-
###2###############/#####################
#########AG0#################Q# A0|#################FC#### ##
#############@#########f###################?
F###&##########9#P####S#{###########d#########d#########
###Simplified
#
#########
#################
#########
#######d#########d#########r####j#o########A#d#########Z#############
Recursion (contd)
################# #############################d#########Z#####-
###2####j## #########d#########Z#####.######Easy to solve it
recursively!Hanoi(Source, Dest, Temp) =# if empty(Source) then# return;# else
begin# Hanoi(AllButBottom(Source), Temp, Dest);# Move(Source, Destination);#
Hanoi(Temp, Destination, Source);# end;#
############################# ##########################A##
#d#########Z##########@##
#d#########Z#######8###5#########################6###7####7D4###9###############0#
####################
#########AG0###############
B# A0|
################<#C#######ed######r####j#o########A#d#########Z##
###########Well, almost...s
#################
#############################d#########Z#####.###2####j##
#########d#########Z#####/######In fact, there is an easy non-recursive
solution:Imagine the pegs arranged in a triangle. On odd-numbered moves, move the
smallest disk one peg clockwise. On even numbered move, make the only legal move
not involving the smallest disk. (See Aho, Hopcroft & Ullman).... but it is not
obvious how this was derived.So, without recursion you must either:Work hard ......
or be clever.Strong advantage for recursion.l
##########2##############################0###############f######################
####2###A##
#d#########Z##########A##
#d#########Z#######0###A##
#d#########Z#######'###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######?###<#########################=###>###$
w>;###@###############1#####################
#########AG0#################M# A0|
################\#C#######mo######r####j#o########A#d#########Z##
###########Procedure implementation
#################
#############################d#########Z#####/###2####j##
#########d#########Z#####0#######How are procedures implemented?On each call
to a procedure storage needs to be allocated to hold:Local variablesFormal
parametersEtc.This storage is called an activation record.A data structure to hold
all the necessary information.Contains the state for each activation.
#######
###
###############C###################################################################
############################################################a######################
##### ###A##
#d#########Z#######C###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######-###A##
#d#########Z#######8###A##
#d#########Z#######'###A##
#d#########Z#######F###C#########################D###E####WCB###G###############2#
####################
#########AG0###############M# A0|################,
I###############r####j#o
#########d#########Z#############FORTRAN#
#################
#############################d#########Z#####0###2####j##########A#d
#########Z#########P###FORTRAN is non-recursive.Only one activation of each
procedure can exist at one time.For each procedure defined in the program, the
compiler allocates spacef or one A.R.Therefore, the total storage required to for
data (and everything else) is fixed.We really shouldnt call this an activation
record!We should call it static data.
#P########################################K#######################################
########R#################P#############A##
#d#########Z#######=###A##
#d#########Z#######U###A##
#d#########Z#######R###A##
#d#########Z#######4###A##d#########Z###########A##d#########Z#######M###J###
######################K###L#####/DI###N###############3#####################
#########AG0###############M# A0|#################IQ###
#####################a##################IQ###
######################a###################IQ###
#######################a################### IQ###
#######################a##################l#IQ###
#######################a##################t#T##`###w###############\#
MP####@#####################P####`######################P####
########################P####@########################P####0##################
##########&#e###############
#I####A##################
I######################################h###############L IP#####
#######################Q### #######################`###w###############
I2########2#####3####P##########d#########d#############a
###############################################d#########d#########3####P#
##########d#########d#############br
###############################################d#########d#########3####P##
##########d#########d#############xt
###############################################d#########d#########3####P#z#
##########d#########d#############yR
###############################################d#########d#########3####P#j#
##########d#########d#############z#
###############################################d#########d#########9#p####H#
##########d#########d#############Formal#parameters#
###############################################d#########d#########9#####^#T##
##########d#########d#############Local#variables#
###############################################d#########d#########9#
######Z#K###########d#########d#############Ret addr
###############################################d#########d#########r####j#o
#########d#########Z#############FORTRAN (contd)
#################
#############################d#########Z#####1###2####j##########A#d
#########Z#########"###What do A.R.s in FORTRAN contain:
#"#########"#################"#########"###A##
#d#########Z#######T###Q#####################
###R###S####WCP###U###############4#####################
#########AG0#################M# A0|################$#M##a#
#################F##a################# #QP#########

#####################ed#####3####Zx###########d#########d#2#######E###
SUBROUTINE A(X, Y)#INTEGER X,Y,Z#Z = 1#X = Z * 2#Y = X + 3#RETURN#END#
#E#########E###

#############E#########E#######d#########d#2#######3####V#x###########
d#########d#2#######=###SUBROUTINE B(...)#...#CALL A(M,N)#M = M * Z#N = N +
1#...#END#
#=#########=###

#############=#########=#######d#########d#2#######r####j#o########A#
d#########Z#############Return pointer
#################
#############################d#########Z#####2###2####j##
#########d#########Z#####3######The return pointer (or return address)
points back tothe code in the calling procedure.To be executed when the called
procedure is done.#
##########X###############1##########################X###A##
#d#########Z#######1###A##
#d#########Z#######[###X#########################Y###Z###d#w>W###\###############5#
####################
#########AG0################M# A0|
################<#M#######ed######r####j#o########A#d#########Z##
###########Return pointer (contd)#
#################
#############################d#########Z#####3###2####j##
#########d#########Z#####4######When B calls A, it writes into As
activation record the formal parameters and the address of the instruction after
the call.In the case of our example, this is M=M+Z.It then jumps to the code for A.
The last thing that A does is jump to that address.#
##########~###############$################### ###########################
%###############
###############%##########################~###A##
#d#########Z#######+###A##
#d#########Z#######!###A##
#d#########Z#######3###A##
#d#########Z#######b###_#############OO####N
cont`###a#####/D^###c###############6#####################
#######Q###`#0#####################AG0###############,##Q# A0|
#################BQ###@##P########################h###############

#QQ###@P##########################A#(################MQ###@###########
###########Q###@###########################################MQ###@##
########################################MQ###@##@#####################
#61#################d#M###FQ##8###############,#MP###0###############
###############R###############\#C###X##########9#
###P#K###########d#########d#############Ai
###############################################d#########d#########9####P###
##########d#########d#############Bi
###############################################d#########d#########9####pN#d#
##########d#########d#############. . .
###############################################d#########d#########9####n####
##########d#########d#############Memory
###############################################d#########d#########9####
#.##5###########d#########d#########-###Shape doesnt#change
during#execution time.
#-#########-#################-#########-
#######d#########d#########r####j#o########A#d#########Z#############
Return pointer (contd)#
#################
#############################d#########Z#####4###2####j##
#########d#########Z#####5###p###In FORTRAN, the compiler knows the
addresses of the activation records, variables, etc.Known at compile time.
#p#########Z#################################p#########Z###A##
#d#########Z###########A##
#d#########Z#######i###f#####################
###g###h###$#7De###j###############7#####################
#########AG0###############
M# A0|
#################M###############r####j#o########A#d#########Z##
###########More on recursiono
#################
#############################d#########Z#####5###2####j##
#########d#########Z#####6#######In Algol, Pascal, Ada, Lisp, etc.,
procedures are recursive.Q: How many procedure activations can exist at the same
time?A: Who knows? It depends on the program and the data (the run-time profile of
a program).So, A.R.s have to be allcoated dynamically (during execution).
###########=###############################<###############################X#######
########?###########################=###A##
#d#########Z#######>###A##
#d#########Z#######Z###A##
#d#########Z#######?###A##
#d#########Z#######p###m#########################n###o###\#
l###q###############8#####################
#########AG0################M# A0|################
>###############r####j#o########A#d#########Z#############More on
recursion (contd)
#################
#############################d#########Z#####6###2####j##
#########d#########Z#####7#######What kind of data structure is appropriate
to hold the activation records?It needs to change size.NOTE: Procedures are called
in a called first, done last order!If f calls g, then g finishes first.(There are
exceptions, though).So, put activation records on a stack!s
###########K###############################A###############################E#######
########&###########################K###A##
#d#########Z###########A##
#d#########Z#######B###A##
#d#########Z#######%###A##
#d#########Z####### ###A##
#d#########Z#######&###A##
#d#########Z#######w###t####################B'#u###v###/Ds###x###############9##
###################
#########AG0###############<#M# A0|
################l#M###########################################################
########################################################################v##R###
############l

M###v#Rh###############D#C###v##R#################Q###v#Rh##########
######C#######################FQ###p0#@######
############Q###`#####################Q#####
###################Q### #####################Q###p#@0######

############Q#####@###################Q###@#####################Q#####
####################Q###p0#@######
############Q###`#####################Q#####
###################Q### #####################Q###p#@0######

############Q#####@###################Q###@#####################Q#####
#################################9##################d#########d###
##########Ar
###############################################d#########d#########9#
#####K###########d#########d#############B.
###############################################d#########d#########9########
##########d#########d#############Bu
###############################################d#########d#########9#
#####K###########d#########d#############Ce
###############################################d#########d#########9####P.###
##########d#########d#########p###This diagram shows the#state of the
activation stack#after A calls B, B calls B#recursively, and then B calls C.
#p#########p#################p#########p#######d#########d#########r####j#o
########A#d#########Z#############More on recursion (contd)
#################
#############################d#########Z#####7###2####j##
#########d#########Z#####8######The frame pointer points to the current
activation record.Variables are refernces as offsets from the frame pointer.X is
the third integer in the activation record.
##########;###############k##########################;###A##
#d#########Z#######;###A##
#d#########Z#######0###A##
#d#########Z#######~###{#########################|###}###
#Uz##################:#####################
#########AG0################B# A0|
##################M###############r####j#o########A#d#########Z##
###########More on recursion (contd)
#################
#############################d#########Z#####8###2####j##
#########d#########Z#####9#######The A.R.s also contain pointers to code to
be executred when the procedure is done.More on this later!Also, since Algol
procedures can access non-local variables (block structre, remember?) the A.R.s
must provide access to them, as well as local variables.Again, more on this later!i
###########U######################################################################
####U###A##
#d#########Z###########A##
#d#########Z##########A##
#d#########Z###########A##
#d#########Z#########################################t#w>##################;#
####################
#########AG0###############M# A0|
#################M###############r####j#o########A#d#########Z##
###########FORTRAN and recursion=
#################
#############################d#########Z#####9###2####j##
#########d#########Z#####:######FORTRAN doesnt have recursive procedures.
Question: Does that mean that you cant solve recursive problems?Answer: No!
Simulate recursion yourself using a stack.Point:The stack corresponds to an array.
The frame pointer is an index into the array.u
##########+###############################:###############################1#######
########################P##########################+###A##
#d#########Z#######B###A##
#d#########Z#######7###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######-###A##
#d#########Z##########################################D##################<#
####################
#########AG0#################Q# A0|
################\#CQ####P#######################h###############l

MQ###P#####################Q########################Q############
###########Q###p###P########################|
#h################MQ###p#P######################Q###p######################
#####A#|
#(#################Q################################P####p##p##################
###P####p#######################P#####p######################P###0#`0#####
###################f#J################O####q##X###############D#>###
################?
F#####################O###{#a##H###############T##Q#####m#"##########
#####<#OP#####`######################P###`##`######################P###`##p#
########################b##########9#
#####RK###########d#########d#############6#
###############################################d#########d#########9#
#####B#K###########d#########d#############7#
###############################################d#########d#########9#####^#B###
##########d#########d#############8#
###############################################d#########d#########9#`######
##########d#########d#############B#
###############################################d#########d#########9#####P#;#
##########d#########d#############B calls A(x,y)
###############################################d#########d#########9#`####j#
##########d#########d#############A#
###############################################d#########d#########9#`####Z##
##########d#########d#############Bp
###############################################d#########d#########9######~##+
###########d#########d#############. . .#
###############################################d#########d#########9####
##3#############d#########d#########,###SUBROUTINE A(C, D)#INTEGER C, D,
E#E = 6 ...
#,#########,###

#############,#########,#######d#########d#########r####j#o########A#
d#########Z#############FORTRAN (parameter passing)#
#################
#############################d#########Z#####:###2####j##
#########d#########Z#####;###u###FORTRAN uses pass by reference.In A.R. =
local variables hold values.Parameters hold addresses of actual arguments.#
#u######### ###############U#################u######### ###A##
#d#########Z#######'###A##
#d#########Z#######.###A##
#d#########Z############################### #########
#w>##################=#####################
#######Q#####@#####################AG0################M# A0|
##################QQ###@@########################V1#################d
#OQ###@#########################/D###############\#OQ###@###########
#############$#P################O###F1#################4
#Q###F################L
#QQ#####@P###################Q###@########################W#############
#####
OQ###@##`######################W##x###############,#CQ###@`##
######################$Q#P8###############T#F###F##################O##
#F##x################O###VT###############L#O###Vf#T##############
####Q##a#@#5#################O##a#0#@0
5#################QP####@#P######

#################&###A(#####9###N##########d#########d############
#9#
###############################################d#########d#########9####i##
###########d#########d#############11
###############################################d#########d#########9#P###^##{#
##########d#########d#############ret#
###############################################d#########d#########9###N
##########d#########d#############xN
###############################################d#########d#########9#######
##########d#########d#############y#
###############################################d#########d#########9#p#####
##########d#########d#############8#
###############################################d#########d#########9#0####[#
##########d#########d#############9#
###############################################d#########d#########9####^n####
##########d#########d#############retc
###############################################d#########d#########9#p#####
##########d#########d#############a#
###############################################d#########d#########9#0####[#
##########d#########d#############b#
###############################################d#########d#########9######
##########d#########d#############A
#####################

#########################d#########d#########9#0#####i###########d####
#####d#############Bt
#####################

#########################d#########d#########3####]f#############d###
######d#2#######E###procedure B(...)#integer a,b;#begin# a := 8;# b := 9;#
A(a,b);#end#
#E#########E###

#############E#########E#######d#########d#2#######3####j#]#############
d#########d#2#######E###procedure A(x,y)#integer x,y;#begin# x := x+1;# y :=
y+2;# ...#end#
#E#########E###

#############E#########E#######d#########d#2#######r####j#o########A#
d#########Z############Pass by value
############### ###########################d#########Z#####;###2####j##
#########d#########Z#####<###L###In Pascal, C, etc., pass by value is the
default.All variables hold values.
#L#########2#################################L#########2###A##
#d#########Z###########A##
#d#########Z#########################################<#w>##################>#
####################
#########AG0#################Q# A0|
#################O#######A(######r####j#o########A#d#########Z##
###########Pass by value-result
#################
#############################d#########Z#####<###2####j##
#########d#########Z#####=### ###Pass by value-result is just like pass by
value.All variables represented by valuesDuring execution of procedures,
assignments to formal parameters have no effect on actual parameters.When a
procedure is done, the values of the formal parameters are written over the actual
parameters.
# #########1##############################e################# #########1###A##
#d#########Z#######$###A##
#d#########Z#######f###A##
#d#########Z#######e###A##
#d#########Z#######################/s####ng (co######L#/D##################?
#####################
#########AG0###############/D# A0|
################$#/D###############r####j#o
#########d#########Z#############Example#
#################
#############################d#########Z#####=###2####j##########A#d
#########Z############Consider:SUBROUTINE FOO(X,Y,Z)#INTEGER X,Y,Z#X = 1#Z = X +
Y#RETURN#END#...#N = 2#CALL TEST(N,N,M)What is the value of M after the call?Pass
by reference: 2Pass by value-result: 3o
##########
###############Z### ###########'###############,##########################
###A##
#d#########Z#######Z###@##
#d#########Z#######'###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z##############################F"#######d#7D##################@#
####################
#########AG0################M# A0|
#################F###############r####j#o########A#d#########Z##
#######
###Pass by name
#
#########
##### ###########
#########
#######d#########Z#####>###2####j## #########d#########Z#####?
######Pass by name (Algol)We already know that a thunk is passed.A parameterless
procedure.Actually, a pointer to the code for the thunk is placed in the A.R.So, in
the A.R.:Local variables are values.Formal parameters are pointers to code.
########################################################A##
#d#########Z#######(###A##
#d#########Z###########A##
#d#########Z#######D###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######'###A##
#d#########Z#########################################
##################A#####################
#########AG0###############\#O# A0|
################4#O##a#0pP################OP###PP######
##############Q###`###`#################M###S#x###############
O###F###x###############
#OQ###`###################M###[###############\#O###F############
#####\
#QQ###`# ##################M####[###############
O###F####################CQ###`######################M#####2##########
######T#O###F#####################CQ###`#P#####################M###A#b#
(###############<#####F#A###(###############\
#QQ###`####P#################M#####h###############\#O###F####h########
#########CQ###`#####################M####2##################O###F###
#################OP##############################E##############|
##P####@#0#########################a###################P######0#######
###############P####@0#P########################V###################

O###h###ma#####3####j############d#########d#2##########procedure
A(x,y);#integer x,y;#begin# integer z;# z := 7;# ...#end##procedure
B(...);#begin# integer m,n,i,y;# ...# A(m+n,i+j);# ...#end
#############

#############################d#########d#2#######9#0#####[###########
d#########d#############z#
###############################################d#########d#########9#0#####[#
##########d#########d#############z#
###############################################d#########d#########9#p##!
###########d#########d#############y#
###############################################d#########d#########9###.!
###########d#########d#############x#
###############################################d#########d#########9#######
##########d#########d#############i
###############################################d#########d#########9####^#(###
##########d#########d#############n
###############################################d#########d#########9#
####Q#K###########d#########d#############m
###############################################d#########d#########9#`#####
##########d#########d#############j
###############################################d#########d#########9#P##
##(##########d#########d#############Compute#m+n#
###############################################d#########d#########9#######~##
##########d#########d#############Compute#i+j#
###############################################d#########d#########9#####.###
##########d#########d#########&###The thunk knows which#m, n and i, j.
#&#########&#################&#########&#######d#########d#########r####j#o
########A#d#########Z#############Pass by name (contd)#
################# #############################d#########Z#####?
###2####j## #########d#########Z#####@####### #
###########################################A##
#d#########Z############# #
##########################/D##################B#####################
#########AG0###############\
F# A0|
################l##Q#######i+######r####j#o########A#d#########Z##
###########Dynamic arrays
#################
#############################d#########Z#####@###2####j##
#########d#########Z#####A###C###Unlike FORTRAN and Pascal, Algol has dynamic
arrays.These are arrays whose size is determined during execution.Another reason,
besides recursion, for dynamic storage allocation.A.Rs for different calls to the
same function may be of different sizes.Location of variables must be determined
(computed) during execution.#
#C#########5###############<###############C################################C#####
####5###A##
#d#########Z#######<###A##
#d#########Z#######C###A##
#d#########Z#######J###A##
#d#########Z#######E###A##
#d#########Z#########################################l#WC##################C#
####################
#########AG0###############
B# A0|################|#>##a#
P#E################OP####0########################V#q#_###############
L

O###&###ar#####3####Zmv#(###########d#########d#2#######`###procedure
foo(n);# integer n;#begin# integer array A(1:n);# integer array B(1:n+1);#
...#end
#`#########`###

#############`#########`#######d#########d#2#######9#####m#B###########
d#########d#########5###Size of A.R. is#determined by#value of n at#run-time.
#5#########5#################5#########5#######d#########d#########r####j#o
########A#d#########Z#############Example#
#################
#############################d#########Z#####A###2####j##
#########d#########Z#####B#######Consider the following:#
###########################################A##
#d#########Z###########################################WC##################D#
####################
#########AG0###############d #Q# A0|
################d#M#######ar######r####j#o########A#d#########Z##
###########Example (contd)
#################
#############################d#########Z#####B###2####j##
#########d#########Z#####C######Details:Compiler generates code to compute:
Size of A.R.Offset into A.R. for variable references.A(6) : location (frame pointer
+ 6)B(6) : location ( frame pointer + 12)#
########## ######################################### ###A##
#d#########Z#######$###A##
#d#########Z##########A##
#d#########Z#######*###A##
#d#########Z#######$###A##
#d#########Z#######%###A##
#d#########Z###############################>########
WC##################E#####################
#########AG0################M# A0|#################
M#######)c######r####j#o########A#d#########Z############Back to
Algol#
############### ###########################d#########Z#####C###2####j##
#########d#########Z#####D######Algol 60 wasnt used much.Mainly served as a
model for subsequent languages:PascalAdaCIt was used more in Europe than in the
U.S.IBM stayed with FORTRAN.No I/O made it less portable.#
########################################################A##
#d#########Z#######3###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z#######,###A##
#d#########Z###########A##
#d#########Z###########A##
#d#########Z##########################################w>##################F#
####################
#########AG0###############\#C# A0|
################<#F#######Al######r####j#o########A#d#########Z##
###########Back to Algol (contd)
#################
#############################d#########Z#####D###2####j##
#########d#########Z#####E######You can think of Algol as generalizing the
structures of FORTRAN.Good:Hierarchical program structure:structured loops and
conditionals.RecursionDynamic storageFree format syntax (defined by a CFG)Required
declaration of all names (variables)
##########B#########################################B###A##
#d#########Z###########A##
#d#########Z####### ###A##
#d#########Z#######%###A##
#d#########Z#######
###A##
#d#########Z###########A##
#d#########Z#######&###A##
#d#########Z#######-###A##
#d#########Z##############################>########
/D##################G#####################
#########AG0##################Q# A0|
##################Q###############r####j#o########A#d#########Z##
###########Back to Algol (contd)
#################
#############################d#########Z#####E###2####j##
#########d#########Z#####F######Continued...Bad:Simple data structures
(primitives and arrays)No user defined data typesBaroque control structures (for
loop is too complicated).#
######################################################A##
#d#########Z###########A##
#d#########Z#######/###A##
#d#########Z###########A##
#d#########Z#######;###A##
#d#########Z###########################################7D##################H#
########E#
#########################################
###############################################"###############)###############0###
############7###############>###############E###############L###############S######
#########Z###############a###############h###############o###############v#########
######}########################################################################
##############################################################################
#############################################################################
##########################################################################
###############################################################
%###############,###############3###############:###############A###############H##
#############O###############V###############]###############d###############k#####
##########r###############y#####################################################
##############################################################################
##############################################################################
################### #########E#K####
##NU########
#########AG0################W+# A0|################
GI###$4####################I###$$#4#P###################I###,#X#######
###############q##X###############t#G###{##################G<########
<#####9########;###########d#########d###############
###############################################d#########d#########9####0##
##########d#########d#########/###Copyright 1994 by Ben Goldberg & Matthew
Smosnai
#/#########/#####
###########/#########/#######d#########d#########r####j#o
#########d#########Z#############Slide Title
#################
#############################d#########Z#########2####j##########A#d
#########Z#########/###Body TextSecond LevelThird LevelFourth Levelx
#/#########
###############################
#################/#########
###A##
#d#########Z##########A##
#d#########Z#######
###A##
#d#########Z#######
###A##
#d#########Z########################################## Ap0#
##############|#>##%##/
#
########t#>##L##QA###`p######################F#####!
#7###########################1####QK
#
######W$##d#########d#2###########Page ###
#################
#############################d#########Z#########2####
#s
#########d#########Z#(#######;###Body TextSecond LevelThird LevelFourth Level
Fifth Level
#;#########;#####
###########;#########
#######d#########Z#(############d#########Z#(#####
#######d#########Z#(#####
#######d#########Z#(#############d#########Z#(#############################
#########
7D###########L###############NU########
#########%##/
#
#########7###L7####F#####!#7############################1####QK
#

#####K###d#########Z#############Page ##8
#################
#############################d#########Z##################################
####D##############################NU########
#########%##/
#
########L7###\#w&###F#####!#7############################1####QK
#

#######d#########Z#############Page ###
#################
#############################d#########Z##################################
###l#D##################=*#########3############ ##)##w #D#### #
#@#@#`#`#####@####### ##@##`#####@###############5#5#F#F########## #
##@##`#####@####### ##@##`#####@#######
#@#@##`#####@####'3########'
#####1#####################################
#O##############W#######_#######O##O`#########O#### #9#G7B#
%#p=rG#h#OX#Y#######
#######~##|######################################

#####################################d#d#d#######7########X#Y#########hhh
Y#######D#Ga[3##########(################################d#d#d######
###########X#Y#######]###Y#######X#Z#########(#####3##
######L##
#########F######
4#Dw>##r#### ########### ########### ########### ###########
###########d#########Z###############d#########Z###############d#########Z#
##############d#########Z###############d#########Z#############2#############
#################################################A##d#########Z###########A##
d#########Z###########A##d#########Z###########A##d#########Z###########A##
#d#########Z#############2####
###########
###########
###########
###########
###########d#########Z#(###########d#########Z#(###########d#########Z#
(###########d#########Z#(###########d#########Z#(#########2#############
######################################################d#########d################
d#########d################d#########d################d#########d###############
#d#########d#############3########################################################
########d#########d#############d#########d#############d#########d####
#########d#########d#############d#########d###############################
0#0##############3
###@###_L###################Arial#############Z#####o#o#EsT###############
##################Arial#############Z#####o#o#EsT#######,#######
##################Century Schoolbook#####+#####/
A######>#&##### #################1Courier
New###G7r#&78######t##############s#################"Helvetica#;###
q#&;#######s########F#######################"Helvetica##
tt
ud duLu########E########################Century Schoolbook####O####'#'#######?
#'######################"Helvetica###s#############7777########G###############
#######"Arial#T###############8##$ 7And##############
#################1Courier#sL###77q#&'8L###*###s########:###############,#,####
#{
##
##Apple LaserWriter II NT#pscript#LPT1:##bupsml2 (LPT2:)#Genigraphics Driver on
COM1:#HP LaserJet Plus on \\gbulaser\gbuljml2 (LPT1:)#PostScript (MGXPS24) on
None#PostScript (Micrografx) on None#TeleGrafx - on
None#############################################Apple LaserWriter II NT#########
#W#D###[######
o#d#################,#############################################################
#######################X##Z#Z##################################e#p#####H##NU####
####
######ruG7####################4#X#@#p#p#@###n######8################
######B#B#2#############
### ###############################'##L#######B#######
#################;###

#############################################

################################ ###
#######
############################################################################## ###!
###"#######$###
%###&###'###(###

###
##Oh###+'####Oh###+'0###
##########x############################################# ###########
###
###,######8#######D#######L#######n#######"###Programming Languages I: ALGOL
60#####################Computer Science
Department#######################################Computer Science
Department#########5###@###FI#R#@###&#9O#@####aR#####E###########Microsoft
PowerPoint 4.0##G###p#########8cjJ####
###,#####N#########&###########@#p#
###&###
###########&###$#######TNPP##Microsoft PowerPoint####&###
#TNPP######f#
###&###
###########&#####TNPP########################
###3#############=##############################
#################4#######5###############-###################-
#########q#A#####&###########$<# ########=#######-
######################-######### <#$##########
###&###
###########&###########$$#<#X#########=#######-##############-
######################-################X#<#$#$##########
###&###
###########&###########,#`########=#######-##############-
######################-################`#,##########
###&###
###########&############q##`######p##############"Helvetica#####-
#######.#######
######### ############# ###2
########1#Q#########
###&###
###########&###########{######################"Helvetica#######-
##############.#######
######### #############N###2
#0/###Copyright 1994 by Ben Goldberg & Matthew Smosna#:#,#,#(#####-
#,#####,#,#,#,###-#(###6#,#,###?#-###,#,#,###,###6###C#-
#####,#,#:###5#D#,#(#,#,#########
###&###
###########&###########p0 ######################"Helvetica#####-
##############.#######
######### #############+###2
S####Programming Languages
I:#d###d####G###G##########G#G#T#############################"H
elvetica#Z####-##############.#######
######### #################2
g####ALGOL 60#####G###########
###&###
###########&########### ##x######@##############"Helvetica#####-
##############.#######
######### #############.###2
#####Instructor: Matthew Smosna6#u#k#@#K#u#k#@#u#K#?#6##l#?#?
#u#l##6###u#l#u#k##############p##############"Helvetica#Z####-
##############.#######
######### #################2
#Q
###June 4, 1996Q#X#X#Q#(#Q#(#)#P#Q#P#Q#########
###&###
###########&#####TNPP##############
###&###
###########-####################-
#############################################"System######-
##########################################;### ############Computer Science
Dept. NYU##################;### ############################;###

#############################

C#u#r#r#e#n#t#
#I#D###########################################################################
##################*################################################################
#######################################################################
#######################################################################
###################################################################################
######################################################################

Вам также может понравиться