PROCEDURE P1(< args >):
          < procedure definition >
        END-PROC 
        PROCEDURE P2(< args >):
          < procedure definition >
        END-PROC 
        PROCEDURE P3(< args >):
          < procedure definition >
        END-PROC 
        PROGRAM Main:
	  < declarations and/or executable code >
	  P1(< args >)         #execute P1
	  < executable code >
	  P2(< args >)         #execute P2
	  < executable code >
	  P3(< args >)         #execute P3
	  < executable code >
	END-PROG 

There are other methods that can facilitate conversion of spaghetti code to modularized code, which include:

• Determining the calling hierarchy, which is the structure defined by the calling sequence of procedures. For example, in the preceding p-code, we would have the calling hierarchy MAIN > (P1 P2 P3). It is not necessarily easy to determine the calling hierarchy from spaghetti code, but this information can sometimes be available from software called an execution profiler. Such programs keep a record of control flow and can be used to determine branching and jump behavior (transfers of control).

• Segmenting code according to functionality, i.e., finding what function each partition of code performs, then encapsulating the code into procedures, each of which perform one or two tasks.

• As a last resort, spaghetti code can simply be chopped into pieces of more or less equal length. For example, if the p-code contains assignment statements only, the variables on the left side of assignment statements would specified as the output variables of a procedure that contains those statements. The variables on the right side of the assignment statements would be specified as input variables.

3.2. PASCAL Procedural Organization.

The PASCAL language provides three methods for encapsulating code in procedures. First, the FUNCTION statement specifies a function that accepts values from its argument list and returns a value or result through the function name. Second, the PROCEDURE statement specifies a procedure that accepts values from its argument list and returns one or more values through its argument list. Third, the PROGRAM statement allows the programmer to specify high-level source code that calls predefined procedures to implement a structured software system. We define these statements as follows:

PROGRAM specification statement:

Purpose: The Program statement specifies the name of a main program (i.e., the top-level procedure).

Syntax: PROGRAM program-name ( input-file , output-file ) ; where

program-name denotes the name of the program

input-file denotes the name of the file from which the program reads input

output-file denotes the filename to which the program writes output.

Example:

PROGRAM Prog1 (myfile.dat, myfile.rpt);

PROGRAM Prog1;

Notes: The input and output file names and their associated parentheses are optional, and may or may not work with various operating systems (e.g., DOS, UNIX, etc.)

PASCAL programs have three parts:

1. Program and variable specification section;

2. Subordinate procedure declarations; and

3. Main program executable code.

      DO THIS                        NOT THIS
-----------------------     ----------------------------
MAIN-PROGRAM                MAIN-PROGRAM
  Proc #1 specification       Proc #1 specification    |
    <proc-1 code>                Proc #2 specification |
  Proc #2 specification            <proc-2 code>       |
    <proc-2 code>                <proc-1 code>         |
  Proc #3 specification       Proc #3 specification
    <proc-3 code>                <proc-3 code>
  <main-program code>       <main-program code>
END.                        END.

FUNCTION specification statement:

Purpose: The Function statement specifies the name of a procedure that inputs values through its argument list and can be thought of as returning a result through its name.

Syntax: FUNCTION function-name ( argument-1 ,..., argument-N ) ; where

function-name denotes the name of the function

argument-i denotes the name of the i-th argument of the function.

Example:

FUNCTION sine(x);

FUNCTION Distance(x,y);

Notes: Do not try to pass output values through the argument list of a function. This can cause problems in some PASCAL implementations.

PROCEDURE specification statement:

Purpose: The Procedure statement specifies the name of a procedure that can input and output values through its argument list.

Syntax: PROCEDURE proc-name ( argument-1 ,..., argument-N ) ; where

proc-name denotes the name of the procedure

argument-i denotes the name of the i-th argument of the procedure.

Example:

PROCEDURE sine(x,output);

PROCEDURE Distance(x,y,output);

PROCEDURE Smile;

Notes: In the preceding examples, the variable output was used for passing results to the calling procedure. In the procedure Smile, there are no input or output variables declared in the argument list, but this procedure (and others) may use global variables, which are discussed in Section 3.4.

BEGIN...END block specification statement:

Purpose: The BEGIN...END statement delimits a block of compound statements.

Syntax: BEGIN <statements> END where

statements denotes more than one Pascal statement.

Example:

BEGIN
  WRITELN('Hello, world');
  WRITELN('Second statement');
  WRITELN('Last statement');
END;		 

Notes: In the preceding example, each statement ends with a semicolon (;). Since the PASCAL design philosophy views each statement as a clause, the semicolon punctuation convention (adopted from English) is employed.

General Comments: Indentation is used to highlight and clarify program structure. For example, each new level of statements should be indented two or three spaces to the right. When a block of statements is closed (e.g., with an END statement), then the indent shifts two or three spaces to the left. Each statement begins on a new line, except for multiple short assignment statements that initialize values in a program.

In the following section, we consider several examples of PASCAL procedural code.

3.3. Writing Modular Code in PASCAL.

   PROGRAM TestFun;               {Program specification}
     VAR x: integer;              {Declare variable x as integer}

     FUNCTION Xcubed(x);          {Function specification}
       BEGIN                      {Function begins here}
         Xcubed := x * x * x;     {Function definition}
       END;                       {Function ends here}

     BEGIN                        {Program begins here}
       x := 4;                    {Assign value to x}
       WRITELN('x3=', Xcubed(x)); {Print value of x^3}
     END.                         {Program ends here}

   PROGRAM TestFun;               {Program specification}
     VAR x,y: integer;            {Declare variables x,y as integer}

     FUNCTION Xcubed(x);          {Function specification}
       BEGIN                      {Function begins here}
         Xcubed := x * x * x;     {Function definition}
       END;                       {Function ends here}

     BEGIN                        {Program begins here}
       x := 4                     {Assign value to x}
       y := Xcubed(x);            {Assign function output to y}
       WRITELN('x3=', y);         {Print value of y}
     END.                         {Program ends here}

   PROGRAM TestFun;               {Program specification}
     VAR x,y: integer;            {Declare variables x,y as integer}

     PROCEDURE Xcubed(x,y);       {Function specification}
       BEGIN                      {Function begins here}
         y := x * x * x;          {Function definition - y gets x^3}
       END;                       {Function ends here}

     BEGIN                        {Program begins here}
       x := 4                     {Assign value to x}
       Xcubed(x,y);               {Procedure call}
       WRITELN('x3=', y);         {Print value of y = x^3}
     END.                         {Program ends here}

3.4. PASCAL Variables and Datatypes.

In PASCAL, valid datatypes that we will consider in this class are:

1. Integer - a whole number, such as 1, 2, etc.;

2. Real - a decimal number, such as -22.7, 231.8942, etc.;

3. Char - a single character, such as 'H' or 'i';

4. String - a list of characters, such as 'Hello'; and

5. Array - a list of variables, such as (1.1, 2.4,..., 3.7) or a two-dimensional array. Higher-dimensional structures are possible.

In PASCAL, a variable name is any string of valid PASCAL characters. We recommend that you use the characters {A-Z,a-z,0-9,_} for your variable names. The following example is illustrative:

              VALID NAMES         INVALID NAMES 
          -------------------   ------------------
              Cost, Price         $amount, @price
              score               score+exam-grade

In PASCAL, variables are typed using the VAR statement, which is described as follows:

VAR specification statement:

Purpose: The VARiable statement specifies the name and datatype of procedure or program variables.

Syntax: VAR varname-1,...,varname-N : datatype ) ; where

varname-i denotes the name of the i-th variable in the list

datatype denotes a valid PASCAL datatype

Example:

VAR x,y,z : integer;

VAR sum,prod : real;

VAR name,ssn : string;

Notes: It is good programming style to specify only one datatype in each VAR statement. It is also good style not to continue VAR statements on multiple lines. This makes the program easier to read.

We next consider the issue of scope of variables. This issue is discussed in detail in Chapter 6 of Koffman, the textbook for this class, from which we condense the following discussion.

Each nested proceudre has its own declaration section and executable code. The latter is also called the procedure body. This is also true for main programs. Figure 3.2 illustrates procedure nesting in a program called Nest. Each rectangle represents a defined procedure, also called a program block.

A program block contains a program module's formal parameter list, which is defined by the VAR statement, as well as the declaration section and procedure body. In Figure 3.2, we illustrate the following procedure nesting hierarchy:

(Nest > (Outer > Inner, Too))

1. Global variables lead to confusion in debugging, when trying to trace variable types through many pages of code.

2. Global variables are convenient to programmers, but they do not make procedures re-usable, since there is no variable declaration at the top of the procedure. In the absence of proper documentation, one cannot know for sure what datatype is assigned to a given variable. This adversely impacts the clarity, reliability, and maintainability of software.

Figure 3.2. Scope of variables in a PASCAL program (after Koffmann, 1992).

• Rule 1. The scope of a variable is the block in which the variable is declared.

  Example. A variable declared as type T in some procedure P is available within P and all its subordinate procedures as a variable of type T.

• Rule 2. The redeclaration of a variable v as having type T within a procedure P holds for P and all its subordinate procedures, but not for higher-level procedures.

  Example. Suppose we have the procedural definition hierarchy Main > (P1 > (P1a,P1b), P2)). That is, P1 and P2 are defined within Main and P1a and P1b are defined within P1. If a variable v is declared within Main as a string but within P1 as real, then v has the type real in P1, P1a, and P1b. However, v retains the type string in Main and P2.

This concludes our overview of software modularity and PASCAL.
We next discuss PASCAL selection structures.