Chapter 5 (5.1 - 5.4) of Programming Languages by Ravi Sethi

1. Chapter 5 (5.1 - 5.4)of Programming LanguagesbyRavi Sethi

2. PROCEDURES • Introduction to Procedures • Parameter Passing Methods • Scope rules for Names • Nested Scope in the Source Text

3. INTRODUCTION TO PROCEDURES • Procedures are constructs for giving a name to a piece of coding(body) • When the name is called , the body is executed. • Function Procedures - Functions • Proper Procedures - Procedures • Functions Return a single value • Procedures have only a side effect such as setting variables or performing • output and returns no value

4. Procedure Calls Use of a Procedure is referred to as a call of Procedure < Procedure - name > ( < parameters> ) The parenthesis around parameters are a syntactic cue to a call Functions are called from within expressions example: r * sin( angle ) Procedures are treated as Atomic statements example : read(ch) ; Actual parameter

5. ELEMENTS OF A PROCEDURE • A name for the declared Procedure • A body consisting of local declaration and statements • The formal parameters which are place holders for actuals • An optional result type • Example function square ( x : integer): integer • (pascal) begin • square := x * x • end ; • Example int square ( int x) • ( C) { • int sq; • sq = x * x; • return sq; • }

6. RECURSION : MULTIPLE ACTIVATION Activation - Each execution of a procedure body is referred to as an activation of the procedure Recursion - A procedure is recursive if it can be activated from within its own procedure body Example- Factorial function function f( n : integer) : integer; begin if n = 0 then f := 1 else f := n * f ( n - 1 ) end ; f(n) is computed in terms of f(n-1), f(n-1) in terms of f(n-2) and so on for n = 3 the sequence of activation is a s follows f(3) = 3 * f(2) f(2) = 2 * f(1) f(1) = 1 * f(0) f(0) = 1 f(1) = 1 f(2) = 2 f(3) = 6

7. 5.2 PARAMETER PASSING METHODS • If communication is desired between the caller and the callee , • arrangements must be made for passing values back and • forth through the procedures parameters. • Parameter passing refers to the matching of actuals with • formals when a Procedure call occurs • Different interpretations of what a parameter stands for leads • to different parameter passing methods. • Call by Value • Call by Reference

8. Gets Own Memory location • Gets initial value from corresponding actual position • Uses but does not change the actual parameter • Actual parameter s can be variables or expressions of a return type • Example • b = future_value(total/2, rate, year2-year1). • Float future_value(float initial_balance, float p, int nyear) • { p = 1 + p/12/100; • int n = 12 * nyear; • float b = initial_balance* pow(p, n) • return b; • } • main future_value Value Parameter total total 1/2 initial_balance rate p rate year1 nyear year 2 year2-year1 b Values are copied into parameter variables expressions

9. Reference Parameters • changes the value of the actual Parameter • Shares the memory location of the actual Parameter • Must match in type • The Actual Reference Parameter must have Location Example procedure swap(var x : integer; var y : integer ); var z : integer; begin z := x; x := y; y := z; end A Call swap(i, A[i]) does the following make the location of x the same as that of i; make the location of y the same as that of A[i]; if i=2 and A[i] = 99 z := 2; i := 99; A[2] := z Thus these assignments exchange values in i and A[i]

10. OBSERVATIONS • Program execution always begins in the main • Formal Parameters(function definition) and actual Parameters (function call) • are matched by position. There names need not agree • Data types of parameters do not appear in the function call • When a function completes the flow of control returns to the place that called it.

11. SCOPE RULES FOR NAMES The Scope rules of a language determine which declaration of a name x applies to an occurrence of x in a program . There are two kinds of scope rules, called lexical and dynamic scope rules. Binding and Scope Consider the following Pascal Procedure procedure swap(var x, y: T) var z : T; begin z := x; x := y; y := z end Binding Occurrence of z Scope of z Bound Occurrence of z The Procedure declaration also contains binding occurrences of the procedure name swap,the formal parameters x and y .The Scopes of the formal parameters x and y and the scope of the variable z consists of the procedure body.

12. LEXICAL AND DYNAMIC SCOPES • Lexical Scope • Also called Static Scope • Binding of name occurrences to declarations done statically, at compile time • A variable that is free in a procedure gets its value from the environment • in which the procedure is defined, rather than from where the procedure is • called • binding of variable is defined by the structure of the program and not by what • happens at the run time. V,W,X (block A) V,Y (block B) V,W,Z (block C)

13. Dynamic Scope • The binding of name occurrences to declarations is done dynamically • at run time • A free variable gets its value from the environment from which it is • called , rather than from the environment in which it is defined. • Dynamic binding should not be confused with dynamic variables • which are either reference variables or local variables.

14. Program L; var n : char procedure W; begin writeln(n) end; procedure D; var n : char; begin n := ‘D’ ; W end; begin { L } n := ‘L’ ; W; D end. { n declared in L } { Occurrence of n in W } { n redeclared in D } { W called within D } { W called from the main program L }

15. NESTED SCOPES- PROCEDURE DECLARATION IN PASCAL Program nested (Input, Output); var X,Y : Real ; Scope of Y Procedure Outer (var X : Real); Scope of M var M,N : Integer ; Procedure Inner ( Z : Real); Scope of Z var N,O : Integer ; begin { Inner} ……….. end : { Inner} begin { outer} - - - - end { outer } begin { Nested } - - - - - - end Nested.