MT311 (Oct 2007) Java Application Development Control Structures, Subprograms and Its Implementation Tutorial 7.

MT311 (Oct 2007)Java Application Development

Control Structures,

Subprograms and Its Implementation

Tutorial 7

2

Tutor Information

Edmund Chiu (Group 2) Email: [email protected] Please begin your email subject with [MT311] Webpage: http://www.geocities.com/gianted

Part I

Control Structures

4

Compound Statements

A compound statement is a collection of statements that can be used in a place where a single statement is allowed– In Pascal, a compound statement is marked at the

two ends by the keyword begin and end– In Java, C/C++, a compound statement is marked at

the two ends by { and }– Variables can be declared in a compound statement

in some languages – this kind of compound statement is called block

Compound statements in C are blocks but not in Pascal

5

Advantages and Disadvantages of Variable Declaration in a Block

A variable can be declared close to where it is used

The variable is not visible outside the block where it should not be used

However, if a number of variables are declared with same name on different levels in nested blocks will greatly decrease the readability of the program as it is difficult to find the true identity of these variables

6

Two-Way Selection Statements

Two-way selection statements provides two execution paths in a program

It will be ambiguous in the case of nested if statement– In Pascal and C, an else clause is always paired with the most

recent unpaired then clause– In Algol 60, a compound statement must be used to enclose

an if statement nested inside a then clause– In Algol 68, Fortran 77 and Ada, special marker such as endif

will mark the end of an if statement

In terms of readability, if-then-else-endif statements are much more readable than if-else statements used in C

7

Multiple Selection Statements

If-then-else-elseif-endif statements are useful because it would enable the statement to be limited to one level

Switch-case is another construct for multiple selectors The writability of switch-case increases if

– Sub-ranges can be specified in the case clause– OR is allowed in the case clause

Reliability is increased by:– Enforce checking on the case lists are exhaustive– Prohibit the control to go from a case to another

8

Iterative Statements – Counter Control Loops

For loops in C and Pascal are examples of counter-controlled loops

Design issues:– Explicitly change the value of a loop variable

Ada does not allow the loop variable to be assigned explicitly increase reliability because no mistaken change to loop variable can be made

If change to the variable is needed, we should use a while loop instead

– Use of a usual variable as the loop variable In Ada, the declaration is integrated into the loop statement and

the variable is only available in the loop In C and Java, the loop variable is declared as other variables –

there is no guarantee the loop variable will not be used by other subprogram

9

Counter Control Loops (cont’d)

– Value change flexibility of a loop variable In Ada and Pascal, we can only increment/decrement the value of

the loop variables by a constant amount In C/C++, the value can be changed using any statements It is very efficient if only increment and decrement of fixed amount

is allowed – loop variable and increment amount are stored in registers

It also decrease the occurrence of an infinite loop– The possibility of exiting from the middle of a loop

Pascal and Fortran do not allow such exit except using goto Ada and C allows exit using exit and break respectively – which

directs the flow to the statement after the loop – it is more readable

C also provides the continue construct to skip the rest of statements in one iteration

10

Counter Control Loops (cont’d)

– Are the values of loop variable evaluated once for every iteration

In C, the condition specifying whether the loop should terminate is evaluated before every iteration – value of loop variable may not be evaluated in the final iteration

However, it is not advisable to specify the condition so that the value of the loop variable changes after each iteration

– This would make the loop very difficult to read and check– It is more likely that the loop will not terminate

11

Logically Controlled Loops

Logically controlled loops use a Boolean expression to control the continuity of an iteration

– Pascal: while-do and repeat-until loops– C: while and do-while loops

The condition will be tested every time either before or after an iteration depending on whether it is a pre-test or a post-test loop

Exit or break construct increases the writability of the language Generally, a while loop is a more flexible way of iteration

– However, a greater flexibility may mean it is more likely to become infinite looping

– Also, for loop usually generates a more efficient code– In case of Ada, using a while loop will lose the reliability provided by the

for loop (loop variable checking)

12

Unconditional Branching

Goto statement (unconditional branching) is a dangerous construct

– Goto makes programs virtually unreadable and unreliable

So, why does the languages still include goto?– It provides a way to exit from a number of deeply nested loops

or procedure calls– When there is an exception inside a deep call, we can also

use goto to force the program to restart It can be done more appropriately by using exception handling

provided in Java, C++ and Ada.

Part II

Subprograms

14

Subprograms

General characteristics– single entry point – calling unit is suspended during the execution of the called

subprogram– control always returns to the caller after the subprogram

terminates Parts in a subprogram

– Definition – the interface to the subprogram– Header – specifies the name, return type and the parameter

list for a subprogram– Prototype – function declarations that comes before the

definition, just like the case in variables (used in C and C++)

15

Non-local Variables vs. Parameters in Subprograms

Subprogram gains access to data through– direct access to non-local variables– parameter passing

Accessing non-local variables is unreliable– If recursion is allowed, there may be a number of active

instances in the same subprogram at any time– However, the same non-local variables are used each time– That means such information may be tampered with by other

instances of the subprogram and therefore may have been changed unintentionally

– Even not in a case of recursion, we may not want the non-local variable to be tampered with by the subprogram

16

Parameters in Subprograms

The parameters in the subprogram header are called formal parameters– They are bound to other variables when the

subprogram is called

A subprogram call will include a list of parameters to the formal parameters. These parameters are called actual parameters

17

Parameters Binding

Nearly all languages bound the parameters by simple position When the list becomes too long, some languages provides

keyword parameters– Example: Sumer(Length => L, List => A, Sum => S);

Sumer has the formal parameters Length, List and Sum– order of the parameters is not important

Some languages can also have default values for the formal parameters

– In C++, you can even skip omit the last parameters with default values in subprogram calls

– Example: Given the following function header:float pay(float income, float tax_rate, int exemptions=1)You can make this call: pay(20000.0, 0.15);

– However, this design is prone to error though convenient– Other example for variable number of parameter: printf

18

Design issues for Subprograms

Parameter-passing methods Type checking for the parameters Local variables - statically/dynamically

allocated? Subprogram definition in other subprogram Referencing environment in nested

subprograms Overloading Generic Subprograms

19

Local Referencing Environments Local variables in a subprogram are actually implemented as

static or stack dynamic variables Advantages of using stack dynamic variables

– Flexibility – recursive subprogram must have stack-dynamic local variables

– Storage for local variables in active subprogram can be shared with those in all inactive subprograms

Disadvantages of using stack dynamic locals– Cost of time to allocate, initialize and de-allocate the variables in each

activation– Access to local variables is indirect (only known at execution) and

slower – Subprograms cannot retain data variables between calls. – This cause a problem if static variables is not allowed within the

subprogram – global variables are needed to store these values and that decrease the reliability because they may be mistakenly assigned a value in other parts of the program

20

Parameter Passing Methods

A formal parameter can:– receive data from the actual parameter (in mode)– transmit data to the actual parameter (out mode)– do both (inout mode)

Two conceptual models of how data transfers– Either an actual value is copied– Or an access path (a simple pointer or reference) is

transmitted Four implementation models of parameter passing

– Pass-by-value– Pass-by-result– Pass-by-value-result– Pass-by-reference

21

Pass-by-Value

Implementing in-mode semantics Additional storage is allocated for the formal parameters from the

stack The values in the actual parameters are copied to the storage

allocated Advantages

– The original value would not be changed after returning from the function (Beware of parameter with pointers! Contents can actually be changed!!)

– Referencing a value parameter is as efficient as referencing a local variable

– Actual parameters can be variables, constants or expressions Disadvantages

– Storage and copy operations can be costly if the parameter is large (e.g. arrays with many elements)

22

Pass-by-Result

Implementing out-mode semantics – no values is transmitted to the subprogram

Similar to pass-by-value, extra storage is allocated for the formal parameters

Values are copied from the formal parameters to the actual parameters when the subprogram returns

– Actual parameters must be variables– Problem occurs if the same variable is present twice or more

in the actual parameter list in a single subprogram call – as we do not know which value will be assigned first

– Similar to pass-by-value, the method can be very inefficient if the parameter is very large

23

Pass-by-Value-Result

Combines pass-by-value and pass-by-result together for inout mode parameters

Values of actual parameters are copied to the locally allocated storage of the formal parameters when the subprogram is called

Values of formal parameters are transmitted back to the actual parameters at subprogram termination

24

Pass-by-Reference

Access path is transmitted to the subprogram for inout mode parameters.

Actual parameters must be variables Advantages

– No extra storage and data copying is needed– If actual size of a parameter is unknown at compile time, we

need to use pass-by-reference Example: Consider an object of B (subclass of A) is passed as

parameter that supposed to be an object of A. The size of the instances are different, the parameter value cannot be copied because of the different size

Disadvantages– Actual value needed to be accessed indirectly – less efficient– Alias problem may occur

25

Example of Using Different Parameter Passing Methods

void times(int a, int b) {a = 2*a;b = 3*b;

}void main() {

int n=1;int array[3] = {4,5,6};times(n, array[n]);times(n, n);

} Pass-by-Value

– all variables in main will not be changed after both function calls

Pass-by-Value-Result– Before 1st Call:

a is 1 (n), b is 5 (array[n])After: a is 2, b is 15 n in main is 2, array is {4,15,6}

– 2nd call causes a problema is 2 (n modified by 1st call), b is also 2 After: a is 4, b is 6 Which to pass back first!?

Pass-by-Reference– Similar to pass-by-value-result,

After 1st call, n becomes 2 and array is {4,15,6}

– 2nd call – both a & b is pointing to n after all, n becomes 12

26

Passing Constant Reference as Parameter

Sometime, a large size parameter may need to be passed into a method

– Passing through copying wastes storage and time– Passing through access path may change the content of the

parameter One way to do the task in C++ is to pass a constant

reference:– Example: void func(const rec1 &r1)

r1 is passed by reference (efficient) and cannot be changed– Compiler will check no assignment statements will be

appeared in the subprogram and if r1 is used to call other methods, it should be passed by value or constant reference

– Also, only r1's const method can be called

27

Implementing Parameter Passing Methods

In most languages, parameter communications takes place through the runtime stack

– Pass-by-value have their values copied into stack locations (storage for the formal parameter)

– Pass-by-result does the opposite – the values are placed in the stack and are retrieved by the calling program when the subprogram terminates

– Pass-by-value-result combines pass-by-value and pass-by-result. The stack location for the parameters is initialized by the call and is then used like a local variable in the called subprogram

– Pass-by-reference place the actual parameter address in the stack regardless of its data type. Reference to constants may leads to big problem if compiler does not prevent the careless change of contents.

28

Calling sub(w, x, y, z) in main

w: pass by value

x: pass by result

y: pass by value-result

z: pass by reference

29

Overloaded Subprograms

Just like overloading operators, subprograms can also have a same name but operating on different data types.

Any function call will be analyzed by the compiler and the compiler will invoke the correct function in accordance to the parameter list used in the call.

To maintain readability, we should only overload subprograms when the subprograms having the same name are to perform similar tasks on data of different types

30

User-Defined Overloaded Operators

In Ada and C++, programmers can overload the operators in the same way they overload the subprograms– Example in C++ – dot product using * operator:

int operator * (const vector &a, const vector &b, int len);

– Providing operator overloading makes some expressions much more readable

– However, if the operator is overloaded too much, the readability will decrease as there are too many meanings attached to the operator

31

Generic Subprograms

Assume we are writing a subprogram that sorts an array of unspecified element type

– Writing overloaded subprograms may require us to write many different functions that do the totally same job

– Generic subprogram (in C++ & Ada) saves us from the trouble. Different versions of the array sorting function will be generated by the compiler once the generic function is ready.

In C++, generic functions have the descriptive name of template functions

32

Generic Sorting Subprogram in C++

template <class Type>void sort(Type list[], int len) {

int top, bottom;Type temp;for (top=0; top<len-2; top++) {

for (bottom=top+1; bottom<len-1; bottom++) {if (list[top] > list[bottom]) {

temp = list[top];list[top] = list[bottom];list[bottom] = temp;

}}

}}

Part III

Implementing Subprograms

34

Semantics of Calls and Returns

Four issues for subprogram calls in addition to the transfer of control

– parameter passing– allocation of storage to local variables– provide the access to nonlocal variables (e.g. global) that are visible

in the subprogram according to the scopes of the variables– save the execution status of the calling unit

Four issues for subprogram returns in addition to the transfer of control

– parameter passing– deallocation of storage used for local variables– remove the access to nonlocal variables visible in the subprogram– restore the execution status of the calling unit

35

Simple Non-Recursive Language

In the following pages, we will model a language with the following characteristics

– No recursion is allowed– All non-local variables are global variables– All local variables are statically allocated

This simple subprogram consists of two separate parts: – actual code, which is constant– Local variables and data that can be changed throughout the

program activation. It consists of Caller status information Parameters Return address Functional value for function subprograms

36

Activation Record Instance (ARI)

The layout of the non-code part of a subprogram is called an activation record

A concrete example of an activation record is called activation record instance (ARI), which is a collection of data in the form of an activation record

In this example, as the program does not support recursion, there can be only one active version of a given subprogram at a time

The following shows a possible layout for an activation record for a simple subprogram (caller status is omitted for simplicity):

Return Address

Parameters

Local Variables

37

Stack Content of a Program with Simple Subprograms

The stack content shows a main program with three subprograms: A, B and C

– These program units may be compiled in different time

– The executable program is put together by a linker – which patch in the relative target addresses for all calls to main, A, B and C

– Whenever a subprogram is called, the return address (address of next statement) is stored to the return address of ARI

– Address of parameter will also be stored (assuming pass by reference).

– Whenever we need to access the parameter, we access through the stored address

– At the end of the subprogram, control will be passed to the address stored in the Return Address field

C

B

A

MAIN

Code

Return Address

Parameters

Local Variables

C

Return Address

Parameters

Local Variables

B

Return Address

Parameters

Local Variables

A

Local VariablesMAIN

Data

38

Activation Record of Subprogramwith Stack-Dynamic Local Variables

With stack-dynamic local variables, the AR will be more complex because:

– The compiler must handle the allocation and deallocation of local variables

– Recursion adds the possibility of multiple instance of ARI exists at the same time

Thus the activation record will need to have two more fields

– Dynamic link stores the pointers to the top of ARI of the caller – used in destruction of current ARI when the procedure is completed. The pointer can only be known during runtime

– Static link shows stores the pointer to the bottom of its static parent. It will be known during the compile time

39

An Example without Recursion

Consider the following skeletal C program:

void fun1(int x) {int y;… // Point 2fun3(y);…

}void fun2(float r) {

int s, t;… // Point 1fun1(s);…

}

void fun3(int q) {

… // Point 3

}

void main() {

float p;

…

fun2(p);

…

}

40

Stack Contents for the Sample Program

At point 1 At point 2

TOP

pLocal VarARI for main

Return Add (main)

Dynamic Link

rParameter

sLocal Var

tLocal Var

ARI for fun2

Dynamic Link

TOP

yLocal Var

ARI for fun1

xParameter

Return Add (to fun2)


Return Add (main)

Dynamic Link

rParameter

sLocal Var

tLocal Var

ARI for fun2

41

At Point 3

qParameterARI for

fun3Dynamic Link


Dynamic Link

TOP

yLocal Var

ARI for fun1

xParameter



Return Add (main)

Dynamic Link

rParameter

sLocal Var

tLocal Var

ARI for fun2

42

Summary for the Above Example

An ARI of a subprogram is created in the stack when the subprogram is called– The return address, the static link (ignored) and the

dynamic link are stored – Parameter are pushed onto the stack accordingly– Local variable are then allocated from the stack one

by one. The local offset from the bottom of the current ARI will be noted so that these variables can be accessed

– Access to non-local variables are made through the ignored static links

43

An Example with Recursion

int factorial(int n) {

// Point 1

if (n<=1) return 1

else return (n*factorial(n-1));

// Point 2

}

void main() {

int value;

value = factorial(3);

// Point 3

}

44

Stack Contents for the Recursive Program

Point 1, 1st call Point 1, 2nd call

?

3

?

TOP

valueLocal VarARI for main

Return Add (main)

Dynamic Link

nParameter

Func. Value

1st ARI for

factorial

?

3

?

2

?

Dynamic Link

TOP

Functional Value

2nd ARI for

factorial

nParameter

Return Add (to factorial)


Return Add (main)

Dynamic Link

nParameter

Functional Value1st ARI

for factorial

45

Point 1, 3rd Call

n1Parameter


Dynamic Link

?Functional Value

3rd ARI for

factorial

?

3

?

2

?

Dynamic Link

TOP

Functional Value

2nd ARI for

factorial

nParameter



Return Add (main)

Dynamic Link

nParameter


for factorial

46

Point 2, after 3rd Call completed

n1Parameter


Dynamic Link

1Functional Value

3rd ARI for

factorial

?

3

?

2

?

Dynamic Link

TOP

Functional Value

2nd ARI for

factorial

nParameter



Return Add (main)

Dynamic Link

nParameter


for factorial

47

Stack Contents for the Recursive Program

Point 2, 2nd call completed

Point 2, 1st call completed

?

3

6

TOP

valueLocal VarARI for

main

Return Add (main)

Dynamic Link

nParameter

Func. Value1st ARI

for factori

al

?

3

?

2

2

Dynamic Link

TOP

Functional Value

2nd ARI for

factorial

nParameter



Return Add (main)

Dynamic Link

nParameter


for factorial

48

Implementing Non-Local References with Static Chains

program A;var a1: integer;procedure B;

var b1: integer;begin ... end;

procedure C;var c1: integer;procedure D;var d1: integer;begin ... end;procedure E;var e1: integer;beginC;e1 := c1;end;begin ... end;

begin ... end;

C is static parent of D and E A is static parent of C When D is executed, non-local

variables (e.g. a1, e1) must come from static ancestors

When D is called, C must be already active, though D may not be called from C

49

Symbol Table during Compilation

No ARI is setup by the compiler Compiler builds the symbol table (not part of the code)

and uses it to build up the ARIs in runtime When the compiler encounters the definition of a

procedure, it inserts the function name into a symbol table

– Other information include static depth, type, address and etc. are also stored

The static depth will be then increased by 1 Reference fields contain

– if the type is a procedure, it will be the address of such function

– if the type is a variable, it will store the offset of the variable

50

After B’s header is read:

After B’s variable is read:

51


When the compiler comes to the end of the procedure definition, it removes all entries with current depth from the table– The depth count is thus decreased by 1

– Note that b1 has been removed but B is still here

52


When the compiler comes to a procedure call, it will look at the entry of the procedure at the symbol table

– static depths are found and used to calculate to where the static link of the new ARI should link

The following page shows the symbol table at the line when E calls C

– The static depths of C and E are 1 and 2 respectively– Thus, static link of E will point to the bottom of C and static link

of C will point to the bottom of main program A.

53

Symbol Table (Before E calls C)

54


When the compiler comes to an access of a variable, it will also find out the static depth and offset of the variable from the symbol table

– Only accessible variables (at that accessing statement) will be shown in the symbol table

Take the previous page as an example, when we need to access c1 in E

– Static depth of c1 is 2 and current static depth (counter) is 3.– The nesting depth of c1 in E is the difference between static

depths of c1 and E, ie., 3-2 =1– The variable is located in the static parent and compiler will

generate the access to the variable through the static link (static chain) and the offset address.

55

At the Execution Stage – Formation of ARI

When the control reaches a subprogram call, the return address will be pushed onto the stack

Then, the ARI of the static parent of the called subprogram is found by following the static chain

– Static depths of the caller and called subprogram is stored in the program in compile time

The static link of the new ARI is then set to point to the found location and pushed onto the stack

Then, the dynamic link pointing to the top of the previous ARI is pushed onto the stack

56

At the Execution Stage – Formation of ARI (cont’d)

Parameters are then pushed to the stack Then, the storage for local variables And lastly the control is passed to the

subprogram Non-local varaibles is accessed by following

the static chain a number of times depends on the static depths

When a subprogram terminates, the top ARI will be removed and the top of stack will point to the position pointed by the dynamic link

57

Example Showing the Use of Static Links

Suppose the calling sequence in program A is as follows:

– Program A calls procedure B– Procedure B calls procedure

C– Procedure C calls procedure

E Static depths of A, B, C, E are

0, 1, 1, 2 respectively The stack contents after the

call of procedure E is shown on the right

58

Implementing Non-Local References with Displays

A non-local access of avariables is always to the static ancestors of the current subprogram

When a subprogram is called, its static ancestors must be already active

We can have an array that always points to the ARIs of all different static ancestors of the current program– So, when we need the static ancestor of depth i, we

can find it by looking up the i-th element in the array Such array is called a display

59

Working with Display

When a subprogram is called– If the static depth of the subprogram is k, then the

ARI of the subprogram will store the entry in the display that corresponds to the static depth k.

– The pointer in the display for the static depth k will now point to this new ARI

When a subprogram returns– copy the pointer which has been saved earlier back

to the corresponding entry in the display. – remove the ARI from the stack

60

Example of Using Display

program A; var aa:integer; procedure B; var bb:integer; procedure C; var cc:integer; procedure D; var dd:integer; begin { D starts } aa:=1; if aa=0 then B; end; { D ends }

begin { C starts } D; end; { C ends } begin { B starts } if aa=0 then C; end; { B ends } begin { A begin } aa:=0; B; end; { A ends }

61


In the above program, the subprogram calling sequence is as follows:– A calls B– B calls C– C calls D– D calls B– B calls C

62


When ARI of A is pushed onto the stack:

When A calls B– static depth of B = 1– no display entry 1 yet

63


After C and D are invoked:

When D calls B again– 2 ARIs for B in the stack– Display has entry for static

depth = 1– the new ARI stores the old entry

and display points to the new one

64


When 2nd call of B returns

– Display entry 1 restores the saved ARI for B

When D returns

65

Accessing Non-Local Variables Using Display

To access a non-local variable, we need to know:– the display offset – the static depth of the variable– the local offset - the location of the variable from the

corresponding ARI In procedure D in our example

– variable aa is referenced– display offset of aa is 0 (found in the symbol table)– local offset of aa is also stored in the symbol table– We can then find aa through the display

66

Implementing Dynamic Scoping

In a dynamic scoping languages, the actual identity of a non-local variable is not know until runtime

Two different methods are used to implement dynamic scoping– Deep access– Shallow access

In both methods, static link is no longer present in ARIs

67

Deep Access

Deep access apply a concept similar in static scoped language with nested subprograms

References to non-local variables can be resolved by searching through the ARI that are currently activated through the dynamic links

The dynamic chain links all subprograms ARI in the reverse order in which they were activated – that is exactly the way we find the non-local variables in a dynamic scoped language

68

Example Using Deep Access

program A {int x, z;…

}procedure B {

int x;…

}procedure C {

int y;…

}procedure D {

print x, y, z;}

Call sequence:– A calls B– B calls C– C calls B– B calls D

When the execution arrives at D– x is accessed from the 2nd ARI of B– y is accessed through 2nd ARI of B and

then ARI of C– z is accessed through 2nd ARI of B, then

ARI of C, 1st ARI of B and then ARI of A

69

Shallow Access

To avoid the time-consuming search in the deep access method, we maintain a central table for variables when using shallow access

Suppose the sample program on the right has the following calling sequence

– main calls sub1– sub1 calls sub1 (recursive)– sub1 calls sub2– sub2 calls sub3

void sub3() {int x, z;x = u + v;…

}void sub2() {

int w, x;…

}void sub1() {

int v, w;…

}void main() {

int v, u;…

}

70vLocal Variable

uLocal VariableARI for main

Return (to main)

Dynamic Link

vLocal Variable

wLocal Variable

1st ARI for sub1

Return (to sub1)

Dynamic Link

vLocal Variable

wLocal Variable

2nd ARI for sub1

Return (to sub1)

Dynamic Link

wLocal Variable

xLocal Variable

ARI for sub2

Return (to sub2)

Dynamic Link

zLocal Variable

xLocal Variable

ARI for sub3

71

A Central Stack for Shallow Access

When the execution comes to sub3:

wzxvu

sub1sub3sub2mainmain

sub1sub3sub1

sub2sub1

MT311 (Oct 2007) Java Application Development Control Structures, Subprograms and Its Implementation Tutorial 7.

Documents

loop statement

loop variable ada

loop pascal

loop variables

values of loop variable

loop variable changes

posttest loop exit

c slide