Question

Given the following program in a C-like syntax, what does F1(m) return assuming static scoping and dynamic scoping? You can assume that expressions are evaluated from left to right.

int m = 3;
int F1(int i) {
    return (i + F2(m) + m);  }
int F2(int j) {
  j++;
  return (j * m); 
}
int main() {
  int m = 5;
  F1(m); }

Explain in details how you got the answers to earn full credit. Don't just write the answer.

a- If parameters are passed by value.

b- If parameters are passed by reference.

c- If parameters are passed by value-result.

Answer 1

(1)static scoping is used
int m = 3;
//in F1() function global m(3) will be used
int F1(int i) {
return (i + F2(m) + m); }//5+12+3 = 20

//in F2() function global m(3) will be used
int F2(int j) {
j++; //3+1 = 4
return (j * m); //return 4*3 = 12
}
//Here local m(5) will be used
int main() {
int m = 5;
F1(m); }

Here F1(m) will return 20

(2)Dynamic scoping is used
int m = 3;
//in F1() function m(5) will be used
int F1(int i) {
return (i + F2(m) + m); }//5+30+5 = 40

//in F2() function global m(5) will be used
int F2(int j) {
j++; //5+1 = 6
return (j * m); //return 6*5 = 30
}
//Here local m(5) will be used
int main() {
int m = 5;
F1(m); }

Here F1(m) will return 40

a- If parameters are passed by value.
Any modifications to the formal parameter variable inside the called function or method affect only the separate storage location and will not be reflected in the actual parameter in the calling environment. Hence output will be 20(static scoping considered)

b- If parameters are passed by reference.
Any changes to the formal parameter are reflected in the actual parameter in the calling environment as formal parameter receives a reference (or pointer) to the actual data.
int m = 3;

int F1(int i) {
return (i + F2(m) + m); }//5+16+4 = 25

//in F2() will modify value of m as m is passed as reference
int F2(int j) {
j++; //3+1 = 4 also m=4
return (j * m); //return 4*4 = 16
}
//Here local m(5) will be used
int main() {
int m = 5;
F1(m); }

output = 25

c- If parameters are passed by value-result.
Just before the control is transferred back to the caller, the value of the formal parameter is transmitted back to the actual parameter.

int m = 3;

int F1(int i) {
return (i + F2(m) + m); }//5+12+4 = 21(Here m get modified)

int F2(int j) {
j++; //3+1 = 4 Here m=3(as m has not modified ,it will get modified only when control back to F1())
return (j * m); //return 4*3 = 12
}
//Here local m(5) will be used
int main() {
int m = 5;
F1(m); }

output = 21