Nested Function Calls and the Call Stack

The Detour Created by a Call

A function call is a detour in the normal path of execution. The program reaches a call in the current function, temporarily moves into the called function's body, and then returns to the caller when that function completes. The next statement is not necessarily the next statement written below the call in the same function: execution first follows the called function.

Tracing One Detour

Consider a main program that needs the area of a rectangle. It calls a helper function to perform that calculation. To trace the execution, do not read only from the first line of the file to the last. First identify the main program or first executable statement, then follow each call as it occurs.

How the Call Stack Remembers

The program must remember where to resume after a function finishes. The call stack provides this memory. Each time a function is called, the program stores information about the current location, called the return address, on the call stack. When the function completes, the program removes that return address from the stack and uses it to return to the caller.

A nested call adds another layer to this process. If function A calls function B, the return location for A is stored. If B then calls function C, the return location for B is stored as well. When C completes, execution returns to B. When B completes, execution returns to A. Each call adds a return address, and each return removes one.

Nested Calls Return Outward

The order for nested calls is therefore inward on calls and outward on returns. Execution moves from A into B, from B into C, then back from C to B, and finally from B to A. This order follows the calls that actually occur, not the order in which the function definitions are placed in the source file.

Reading Execution Order

1. Locate the first executable statement or the main program.
2. Move forward until you reach a function call.
3. Record the statement or location that should run after the called function finishes.
4. Enter the called function and trace its statements.
5. If that function calls another function, repeat the same process for the nested call.
6. When the current function completes, return to the most recently saved return location.
7. Continue tracing from that return location rather than restarting the caller.

This method separates source-code order from execution order. Function definitions may appear before the main program in a file, but their bodies run only when the program calls them. A reliable trace follows the calls made during execution and records where each call must return.

Mistakes in Call Tracing

• Assuming execution follows the source file from top to bottom

  Execution starts at the main program or first executable statement and enters a function when that function is called.

  Fix: Trace the calls that actually occur instead of relying on the placement of definitions.

• Skipping the function body when tracing a call

  The called function's body runs before execution returns to its caller.

  Fix: Enter the called function, trace it fully, and then continue at the saved return location.

• Returning to the wrong caller after a nested call

  The most recent call was made by B, so C returns to B first.

  Fix: Use the most recently stored return location, then continue outward one completed function at a time.

• Assuming the program forgets where it was after a call

  The call stack stores the return address for resuming the caller.

  Fix: Resume at the statement associated with the saved return location.

Practice the Prediction

What to Remember

1. A function call redirects execution from the caller to the called function's body.
2. After the called function completes, execution resumes in the caller at the saved return location.
3. The call stack stores return addresses, adding one for each function call and removing one for each return.
4. Nested calls return in the reverse order of the calls: the most recently called function returns first.
5. Execution order depends on which functions are called, not simply on where their definitions appear in the source file.