The variables that are used to pass values to a subroutine are normally left unchanged. However, actual arguments can also be passed by reference to a subroutine. When an argument is passed by reference, the reference to the variable itself is passed instead of the variable's value. This means that any changes to the variable inside the subroutine are reflected in the variable's value after the subroutine completes. This permits an additional way to return values from a subroutine. To pass a variable by reference we use the var directive in the arguments list. For instance, consider the following program that is meant to swap the values in two integers:

This code does not work properly because the actual arguments X and Y are passed by value to Swap which then stores these values for processing in I1 and I2. In other words, X and Y may contain the same values as I1 and I2 initially, but these values are stored in different locations in memory which means that I1 and I2 are discarded after Swap exits. Placing a var directive in the formal argument declaration fixes the problem:

This code properly swaps the values of X and Y because the actual arguments X and Y are passed by reference to Swap. This means that I1 and I2 reference the same location in memory as X and Y so that any changes to I1 will automatically result in a change in X. Thus, after Swap exits, X contains 10 and Y contains 5.

Subroutines can also have their own local variables which are distinct from the main program's global variables and invisible to the main program and any other subroutines. For instance, consider the following program:

This program performs the identical task to one we previously wrote in writing the multiplication tables to the screen. The difference is that we previously used a nested loop with two differently named variables K and J. Here we use K in each loop even though the loops are essentially nested. We can do this because the variable global variable K references a different location in memory than WriteMulLine's local variable K. Also note the use of the global variable Max. Max is used in both loops and references the same location in memory both times. This is because global variables are visible everywhere in the program (as long as they are declared on some line above where they are used) while local variables are visible only within a subroutine. Visibility and a related term scope of variables will be discussed both later in this chapter and later in Unit I.