Upon completion of this chapter, you should be able to

In this chapter we focus on some instructions that enable the program to make decisions that affect the order in which statements are executed. Such instructions are referred to as logical control structures.

The full range of logical control structures used in any program, regardless of the programming language, is

In this chapter, we focus first on the IF-THEN-ELSE structure that permits programs to execute one or more instructions depending on the contents of fields. Then, we present the case structure, which is executed using the EVALUATE verb. In the next chapter, we consider iteration in detail, focusing on the PERFORM statement and its options.

A conditional statement performs operations depending on the existence of some condition. Such statements generally begin with the word IF and are called IF-THEN-ELSE or selection structures.

The basic instruction format for IF statements is

Instruction Format

THEN is Optional. The THEN clause in the instruction format is bracketed [], which means that it is optional. When used, it has no effect on the execution of the IF statement. Thus, we will not include it in our examples.

The ELSE is also optional because it is enclosed in brackets. If some operation is required only if a condition exists and nothing different need be done if the condition does not exist, the entire ELSE clause may be omitted.

An imperative statement, as opposed to a conditional statement, performs an operation regardless of any existing conditions. ADD AMOUNT-IN TO AMOUNT-OUT and MOVE NAME-IN TO NAME-OUT are examples of imperative statements that do not test for conditions but simply perform operations. COBOL statements are divided into two broad categories: (1) imperative, which perform operations, and (2) conditional, which test for the existence of one or more conditions. Another way to say that "a condition exists" is to say that "a condition is met" or "a condition is true."

The flowchart and pseudocode excerpts that correspond to an IF-THEN-ELSE selection structure are

Terminating the IF Statement. The IF statement may be terminated with the scope terminator END-IF or a period. When you use a scope terminator, a period at the end of the line is optional, except if it is the last statement in a paragraph. Then it requires a period.

An IF statement may test for a simple condition that may be a single relational test of the following form:

These three tests are considered simple relational conditions. Another example of a simple conditional is

In this example, the message 'NO TRANSACTIONS THIS MONTH' is printed only if AMOUNT-IN is zero. If AMOUNT-IN is not zero, processing continues with the next sentence without performing any operation. The ELSE clause is unnecessary in this instance.

The ELSE clause is used when two conditions exist. That is, the condition being tested can be true or false. In this situation, certain operations are performed when the condition is true, and different operations are performed when the operation is false. Consider the following.

There are two possible results of the test performed by the preceding statement.

Explanation:

By using the word IF, we test the initial condition and perform the instruction specified. By using ELSE, we can perform an operation if the initial condition is not met, or is false.

More than One Operation Can Be Performed When a Condition Exists. More than one operation may be executed for each true or false condition in an IF statement. The following will perform two MOVE operations if AMOUNT1 is equal to AMOUNT2, or two ADD operations if AMOUNT1 is not equal to AMOUNT2.

Notice how the imperative statements (MOVE and ADD) are indented. Indent statements within the IF instruction to make programs easier to read and debug. Use the following coding style for conditionals.

The technique of indenting and coding each statement on a separate line makes reading the program easier, but it does not affect compilation or execution. When an error occurs on an IF condition line, it is easier to determine the cause of error if that line contains a single statement than if it were written as follows.

IF AMOUNT1 IS EQUAL TO AMOUNT2 ADD 5 TO TOTAL ELSE ADD 10 TO TOTAL.

In this sentence, the exact clause or statement that caused an error would be more difficult to determine.

Using Relational Operators in Place of Words. The following symbols for simple relational conditions are valid within a COBOL statement:

A COBOL conditional, then, may have the following form.

Note that a blank is required on each side of the symbols <,>,=,<=,>=. A conditional can also compare a field to an arithmetic expression.

Do Not Mix Field Types in a Comparison. Conditional statements must use fields with the same data types to obtain proper results, as in this statement:

CODE-IN must be an alphanumeric field, since it is compared to an alphanumeric literal. As in MOVE operations, the literal should have the same format as the data item.

If CODE-IN has a PICTURE of 9s, the following conditional would be appropriate.

Similarly, to ensure correct results, fields that are compared to one another should have the same data types, whether numeric or alphanumeric. Thus, in this statement, both COUNTERl and COUNTER2 are either numeric or alphanumeric:

Suppose we write this:

If AMOUNT-IN were a field defined as numeric, but actually contained a blank or any other alphabetic character, the operation would result in a decimal data error, which causes the program to terminate abnormally. This error will occur because numeric fields must contain numeric data when used in arithmetic or comparison operations. Blanks are not valid numeric data. Be certain, then, that if a field is defined as numeric, it actually contains numbers.

When comparing numeric fields, the following are all considered equal.

012 12.00 12 +12.

Numeric comparisons are performed in COBOL algebraically. Although 12.00 does not have the same internal configuration as 012, their numeric values are known to be equal.

Similarly, when comparing alphanumeric fields, the following are considered equivalent:

Low-order or rightmost blanks will not upset the equivalence. Only significant or nonblank positions are compared, from left to right. Consequently, ▵ABC is not equal to ABC▵ since A is not equal to blank.

When performing a comparison, the hierarchy of the comparison, called the collating sequence, depends on the computer being used. As mentioned in Chapter 1, the collating sequence for IBM mainframe and midrange computers is EBCDIC. Characters are compared to one another in EBCDIC:

For numeric comparisons, 012 < 022 < 042, and so on. Similarly, the computer is able to determine if data is arranged alphabetically using uppercase letters, because A is considered less than B, which is less than C, and so on. Thus,

ABCD < BBCD < XBCD, and so on.

Note, however, that lowercase letters are less than uppercase letters. Suppose you are performing an alphabetic sequence check. Smith is considered < SMITH. Note, too, that Stu < SAM. Mixing uppercase and lowercase letters, then, could produce different results in a comparison.

Similarly, if alphanumeric fields are being compared where there may be a mix of letters and digits, letters are less than numbers. Consider the following comparison.

If ADDRESS-IN has a value of 'ROUTE 109', 'ROUTE 109' is less than '10 0 MAIN ST' because the first character, R, compares "less than" the number 1; hence 1 would be added to TOTAL.

If the scope terminator END-IF is not used in an IF statement, the placement of periods can affect the logic. Consider the following.

Because the statement ADD PRICE2 TO TOTAL ends with a period, the last statement, MOVE 0 TO ITEM2, is always executed regardless of the comparison.

The preceding program excerpt may be flowcharted and written as pseudocode as shown in Figure 8.1

If a period were accidentally omitted after ADD PRICE2 TO TOTAL, then MOVE 0 TO ITEM2 would be considered part of the ELSE clause and would not be executed if PRICE1 were less than PRICE2. YOU can see that the placement of the period, then, can significantly affect the logic.

The scope terminator END-IF can be used to definitively specify the boundaries of an IF.

The END-IF marks the boundary of the IF statement without the need for a period. A period is optional after END-IF. If you use scope terminators to delimit instructions, then all periods except for the last one in the paragraph can be omitted.

If you are using an ELSE clause, never place a period before the ELSE. Include an END-IF or period only at the end of the sentence following all imperative statements that apply to the ELSE.

Figure 8.1. Program excerpt and pseudocode for IF statement.

There are times when you might want to execute a series of steps only if a certain condition does not exist. The COBOL expression CONTINUE enables you (1) to avoid performing any operation if a condition exists, and (2) to execute instructions only if the ELSE condition is met.

CONTINUE must be the only clause following a condition, since it indicates that no action is to be performed. Consider the following.

If AMOUNT1 is equal to AMOUNT2, no operation will be performed, and the program will continue execution with the sentence following the END-IF. If

AMOUNT1 is not equal to AMOUNT2, 1 is added to TOTAL, and the program continues execution with the sentence following the END-IF.

We recommend that you avoid using CONTINUE by coding the preceding as follows.

A nested conditional is a conditional in which an IF statement itself can contain additional IF clauses. Consider the following.

This is an example of a nested conditional. Because complex nesting of conditions can sometimes be confusing, we recommend that nested conditionals always be balanced by having each IF clause paired with an ELSE, as shown in the following:

In our nested conditionals, each END-IF scope terminator will be paired with the preceding IF, except for the last END-IF, which is paired with the first IF. The use of END-IF to delimit each IF clause reduces the risk of errors. That is, it can sometimes make a logical difference in the meaning of the full statement. Consider the following comparison.

This example conforms to the original format specified for an IF instruction, but statement-1 is a conditional rather than an imperative statement. This makes this example a nested conditional. The tests performed follow:

This procedure may also be written in terms of a decision table.

Decision tables list the various conditions that may occur and the actions to be performed. Decision tables are frequently prepared by software developers to map out or chart complex logic that requires execution of different modules depending on the results of numerous tests.

A nested conditional is really a shortcut method of writing a series of conditionals.

A nested conditional is used for the following reasons: (1) it minimizes coding effort where numerous conditions are to be tested, and (2) it tests conditions just as they appear in a decision table.

Consider the following decision table.

We could write this decision table as a nested conditional.

The indenting of clauses helps to clarify the relationships between statements and should be consistently employed when coding nested conditionals. This will not only help in reading the sentence, but it will make it easier to debug your program as well. Parentheses may be included for clarification.

Thus, the general format for an IF is this:

Instruction Format

In a nested conditional, statements 1 and 2 above can themselves be conditional statements. END-IF reduces the risk of logic errors. Consider the following.

The compound conditional offers even greater flexibility for selection and enables the IF statement to be used for more complex problems. With the compound conditional, the software developer can test for several conditions with one statement.

To perform an operation or a series of operations if any one of several conditions exists, use a compound conditional with conditions separated by OR. This means that if any one of several conditions exists, the imperative statement(s) specified will be executed. Consider the following examples.

By using OR in a compound conditional, any one of the conditions specified causes execution of the statement(s). If none of the conditions is met, the program either executes the ELSE clause, if specified, or continues with the statement following the END-IF scope terminator. Any number of conditions separated by ORs may be specified in a single statement.

In the second example, 60 0-ERROR-RTN is executed only if AMOUNT1 is greater than or equal to AMOUNT3 and AMOUNT1 is not equal to AMOUNT4. If either AMOUNT1 is less than AMOUNT3, or AMOUNT1 is equal to AMOUNT4, AMOUNT1 will be added to TOTAL, and the next sentence will be executed.

Using the preceding instruction format, note that the following is invalid.

Invalid Syntax:

With compound conditionals, the word IF is specified only once.

In compound conditionals, it is not always necessary to specify both operands for each condition. The following example tests two simple conditions: (1) TOTAL = 7 and (2) TOTAL = 8.

Since the identifier TOTAL is omitted from the second condition test, it is an implied operand. A full condition must be specified following the word IF. In a conditional such as IF condition-1 OR condition-2, condition-1 must include a full test; but subsequent conditions can have implied operands, where the first operand of the next condition is the one that is implied. In the clause IF TOTAL = 7 OR 8, for example, the compiler assumes you mean to compare TOTAL to 8 as well as to 7. The preceding statement can also be written as follows:

Not Greater Than or Equal To Is Equivalent to Less Than

Note that the following three routines produce identical results.

That is, if AMOUNT-IN is not greater than or equal to 5, it must be less than 5.

If a statement or statements are to be executed only when all of several conditions are met, use the word AND in the compound conditional. Thus, either AND or OR (or both) can be used in a compound conditional, as in this example:

Instruction Format

All conditions must be met when AND is used in a compound condition. The ELSE clause is executed if any one of the stated conditions is not met.

Suppose we want to perform 40 0-PRINT-RTN if all the following conditions are met.

AMOUNT1 = AMOUNTA; AMOUNT2 = AMOUNTB; AMOUNT3 = AMOUNTC

If one or more of these conditions is not met, 50 0-ERROR-RTN should be performed. We may use a compound conditional for this:

If all the conditions are met, 40 0-PRINT-RTN is executed. If any one of the conditions is not met, 500 -ERROR-RTN is executed.

There are times when both the AND and OR are required within the same compound conditional. Suppose we wish to write a routine to perform 700 -PRINTRTN if AMOUNT is between 10 and 20, inclusive of the end points (i.e., including 10 and 20).

On first sight, we might consider coding a compound conditional as follows.

This statement, however, will function properly only if AMOUNT is an integer. The number 10 .3, for instance, is between 10 and 20, but it will not pass the preceding tests. For a similar reason, we cannot write

If AMOUNT is 9.8, it is not between 10 and 20; but it passes both tests. Thus, we want to perform 700-PRINT-RTN if

(1) AMOUNT = 10,

We could write the compound conditional as

When using both AND and OR in the same compound conditional as in the preceding example, the order of evaluation of each condition is critical. For example, consider

Suppose A = 2, B = 2, C = 3, D = 4, E = 5,

Order of Evaluation: Possibility 1

IF A = B OR C = D and E = F

If this is the order of evaluation, there are two ways that 600-STEP-1 will be executed: (1) A = B and E = F, or (2) C = D and E = F. That is, E and F must be equal and either A must be equal to B or c must be equal to D. Since E does not equal F, 600-STEP-1 will not be executed if this order of evaluation is correct.

Suppose, however, that the preceding instruction is evaluated as follows:

Order of Evaluation: Possibility 2

IF A = B

If this is the order of evaluation, there are two ways that 600-STEP-l will be executed: (1) A = B, or (2) C = D and E = F. That is, either A and B are equal or C must equal D and E must equal F. Because the first condition, A = B, is met, the PERFORM will occur if this order of evaluation is correct.

Hence, if the second order of evaluation is the one actually used by the program, 600-STEP-l is executed; but if the first is used, the paragraph is not executed. Only one of these evaluations is correct. Now that the importance of the order of evaluation is clear, we will consider the hierarchy rules for compound conditionals:

Using these hierarchy rules and the preceding example, the conditions will be evaluated as follows:

IF C = D AND E = F or A = B.

With A = 2, B = 2, C = 3, D = 4, E = 5, and F = 6, 60 0-STEP-1 will be executed because A = B. To change the order so that the evaluation is performed as in possibility 1 above, write the condition as

In this case, 600-STEP-l will not be executed.

Let us reconsider a previous example, in which we want to print AMOUNT if it is between 10 and 20, inclusive. This is often written mathematically as 10 ≤ AMOUNT ≤ 20; if 10 is less than or equal to AMOUNT and, at the same time, AMOUNT is less than or equal to 20, then we wish to print AMOUNT.

Let us determine if the following statement results in the proper test.

Using the hierarchy rules for evaluating compound conditionals, the first conditions tested are those surrounding the word AND. Then, from left to right, those surrounding the OR expressions are evaluated. Thus, we have

IF AMOUNT = 20 AND AMOUNT = 10

The compound conditional test in possibility 1 is always false because the value for AMOUNT can never equal 10 and, at the same time, be equal to 20. Since the first expression tested will never be true, it can be eliminated from the statement, which then reduces to this:

Obviously, this is not the solution to the original problem. In fact, using the preceding conditional, all values for AMOUNT will cause 700-PRINT-RTN to be executed. If AMOUNT were, in fact, greater than 20, it would cause 700-PRINT-RTN to be performed since it passes the test: AMOUNT > 10. (Any number > 10 passes this test.) If AMOUNT were less than 10, it would cause 700-PRINT-RTN to be executed since it passes the test: AMOUNT < 20. (Any number < 20 passes this test.)

The original statement would be correct if we could change the order of evaluation. We want the comparisons performed according to the following hierarchy:

IF AMOUNT < 20 OR AMOUNT =20
and AMOUNT = 10 OR AMOUNT > 10

To change the normal order of evaluation, place parentheses around the conditions you want to be evaluated first, as a unit. Parentheses override the other hierarchy rules so that all conditions within parentheses are evaluated together. Thus, the following statement is correct.

When in doubt about the normal sequence of evaluation, use parentheses. Even when they are not necessary, as in IF (A = B AND C = D) OR (E = F) . . ., they ensure that the statements are performed in the proper sequence. Moreover, they help the user better understand the logic of a program.

By using the <= and >= operators, the preceding can be simplified as

The EVALUATE verb is used to implement the case structure. This verb can test for a series of conditions and is often used instead of IF statements. The EVALUATE verb has the following instruction format:

Instruction Format

Suppose an input field called YEARS-IN-COLLEGE-IN is used to determine the type of processing to be performed. Using an IF statement, we could write

Once an IF condition is met in a nested conditional and its imperative statements are executed, all the ELSE clauses are bypassed and execution continues after the END-IF.

To ensure correct processing, we added a fifth condition to perform an error routine if the input field is invalid.

The EVALUATE verb enables the series of cases to be written more clearly and efficiently, and in a more structured form. We could write

The WHEN OTHER clause is executed when YEARS-IN-COLLEGE-IN is not 1, 2, 3, or 4.

Once a condition in an EVALUATE is met, there is no need for the program to test other conditions in the statement. Thus, after a condition in a WHEN is met and the corresponding imperative statements are executed, execution continues with the statement following END-EVALUATE.

The flowchart for this case structure is shown in Figure 8.2.

Figure 8.2. Flowchart for case structure.

Note that we can EVALUATE an identifier or an expression such as TRUE. Another way to write the preceding EVALUATE, then, is

We may also use a THRU clause with the EVALUATE. Suppose you wish to print class grades based on a student's average. The following is valid:

We can also write this as

We can use the EVALUATE in conjunction with condition-names as well.

In this instance, GRADE would have condition-names associated with it as follows:

Note that to say EVALUATE GRADE WHEN EXCELLENT . . . will result in a syntax error. You must say EVALUATE GRADE WHEN 1 . . . or EVALUATE TRUE WHEN EXCELLENT. . ..

The EVALUATE statement can be written in numerous ways. These are the three most common:

Example

When evaluating an identifier, the WHEN clause must specify precise values—for example, WHEN 1, WHEN 0 THRU 10, and so on. We could also write EVALUATE TRUE WHEN identifier >= 1 AND <= 20 . ..

In this section, we focus on how IF statement can be used for data validation.

If a numeric field is to have either positive or negative values, we may include a sign test to validate input data.

We can test whether a field is POSITIVE, NEGATIVE, or ZERO with a sign test, as in this example:

Designating Fields as Signed Negative or Positive

To test a field for its sign implies that the field may have a negative value. A numeric field will be considered unsigned or positive by the program unless there is an S in its PICTURE clause. Thus, 05 AMOUNT1 PIC 9(2) is a two-position unsigned field and 05 AMOUNT2 PIC S9 (2) is a two-position signed field, unless SIGN Is LEADING SEPARATE or TRAILING SEPARATE is specified (which would make it a three-position signed field).

If you move −12 to AMOUNT1, AMOUNT1 will contain 12 because it is unsigned. Moving −12 to AMOUNT2 will result in −12 in AMOUNT2, since AMOUNT2

allows for a sign. Use S in a PIC clause of a numeric field that may have negative contents.

The phrase IF A IS EQUAL TO ZERO is the same as IF A IS ZERO. If a numeric field contains an amount less than zero, it is considered negative. If it has an amount greater than zero, then it is considered positive.

−382 is negative 382 is positive +382 is positive

Routines in a program can minimize the risk of errors going undetected, but they cannot be expected to detect all errors. Many of these routines include tests to determine if data is reasonable. Thus, although we may not be able to guarantee the validity of a salary field entered as 35000, for example, we can certainly flag as a probable error a salary field with a value of 998325. Tests for reasonableness include the following.

Range Tests. One way to validate data is to make certain that fields pass a range test; that is, the value contained in a particular field should fall within preestablished guidelines. If a valid account number contains codes from 00001 to 85432 and also from 87001 to 89005, we may include a range test as part of our validity check, like this:

Limit Tests. When a field is not to exceed a given value, we can perform a limit test. For example, a manager may establish a rule that the quantity on hand for any part must not exceed 980 units. The program should make certain that this limit is not exceeded, as in this example:

With a range test, both ends of an identifier are compared, but with a limit test the comparison is in only one direction. To test that AMOUNT1 is > 7 and < 25 is a range test, but to test that AMOUNT2 is > 250 is a limit test.

A WORKING-STORAGE entry may be defined with a VALUE clause in place of a literal in the PROCEDURE DIVISION. Consider the following alternative to the previous example.

In this example, WS-MAXIMUM-QOH is an independent item in WORKING-STORAGE defined as

05 WS-MAXIMUM-QOH PIC 9(3) VALUE 980.

The software developer decides whether to use a WORKING-STORAGE data item to store a constant in a work field or specify the constant as a literal in the PROCEDURE DIVISION. As a general rule, however, any literal that will be used more than once in the PROCEDURE DIVISION should be given an assigned storage area and a data-name in WORKING-STORAGE. Also, if the value may change from time to time, it would be easier to change the VALUE clause in WORKING-STORAGE than to look for the constant in the PROCEDURE DIVISION.

If an input field has a PIC of 9s, the software developer should make certain that the field does, in fact, have numeric data. Suppose we want to add AMOUNT-IN to TOTAL, where AMOUNT-IN is an input field. Since input is always subject to data-entry errors, it is possible that the AMOUNT-IN field might be entered erroneously with nonnumeric data or spaces. In such a case, ADD AMOUNT-IN TO TOTAL would result in a decimal data error, causing the program to terminate abnormally.

The following test may be used to minimize such errors.

If the ELSE option is executed with the NUMERIC class test, then either the field contains alphabetic data (only letters and/or spaces) or it contains alphanumeric data, meaning any possible characters. If AMOUNT-IN contains 123AB, for example, the ELSE clause will be executed since the contents of the field are not strictly numeric.

Use the NUMERIC class test to ensure that a field to be used in arithmetic has a numeric value. If a field is to be alphabetic, you could similarly use the ALPHABETIC class test. Consider the following example of an ALPHABETIC class test:

A one-position field in a record contains the number of dependents an employee claims for income tax purposes. To obtain the exemption amount to be deducted, we multiply the number of dependents by 2000. If, however, the employee claims 10 dependents, an A is placed in the field; if he or she claims 11 dependents, a B is placed in the field, and so on. We should only perform the multiplication if the field does not contain a letter, as follows:

One main source of error occurs when input fields are missing data. If specific fields must contain data, they should be checked before processing continues, like this:

Alternatively, we could use a class test to determine if SOCIAL-SECURITY-NUMBER contains nonnumeric data.

Any letter, either uppercase or lowercase, or blank, is considered ALPHABETIC. The three alphabetic class tests are these:

Consider this example.

Coded fields are frequently used in input records to minimize keystrokes and to keep the input record format shorter. Thus, a field used to indicate an individual's marital status is not likely to be keyed as "SINGLE," "MARRIED," or "DIVORCED." Rather, MARITAL-STATUS might be a one-position field that is coded with 'M' for married, 'S' for single, and 'D' for divorced.

A condition-name is a user-defined word established in the DATA DIVISION that gives a name to a specific value that an identifier could assume. An 88-level entry specified in the DATA DIVISION is a condition-name that denotes a possible value for an identifier. We may use several condition-names along with one field:

When the field called MARITAL-STATUS is equal to 'S', we will call that condition SINGLE. The 88-level item is not the name of a field but the name of a condition; it refers specifically to the elementary item directly preceding it. SINGLE is a condition-name applied to the field called MARITAL-STATUS, since MARITAL-STATUS directly precedes the 88-level item. The condition SINGLE exists or is "true" if MARITAL-STATUS = 'S'.

A condition-name is always specified on the 88-level and has only a VALUE clause associated with it. Since a condition-name is not the name of a field, it will

not contain a PICTURE clause. The condition-name must be unique, and its VALUE must be a literal consistent with the data type of the field preceding it. That is, if MARITAL-STATUS is an alphanumeric field, the condition name must be an alphanumeric literal.

For readability, we indent each 88-level item to clarify its relationship to the data-name directly preceding it. Any elementary item on level numbers 01–49 in the FILE or WORKING-STORAGE SECTIONS may have a condition-name associated with it.

Condition-names are defined in the DATA DIVISION to simplify processing in the PROCEDURE DIVISION. A condition-name is an alternate method of expressing a simple relational test in the PROCEDURE DIVISION.

The condition-names may be used in an EVALUATE statement to determine which routine to execute, as in this example:

In addition, the condition-names may be used in an IF statement, as follows.

In either example above, the condition-names are tested and not the conditional variable MARITAL-STATUS.

Consider this example where condition-names provide a description for letter grades.

Assuming that the above VALUES are the only valid ones, a PROCEDURE DIVISION test may be as follows.

We may also say IF NOT FAILING PERFORM 270-PASS-RTN, if we can be sure that the condition NOT FAILING guarantees an entry from 'A' through 'D' only. But if GRADE contained a 'G' it would be processed improperly in 270-PASS-RTN and not recognized as an error. The following might be better.

CREDIT-GIVEN is a condition that is met if GRADE has a value of 'A', 'B', 'C', or 'D'.

A condition-name may contain a VALUE clause that specifies a range of values. The word THRU is used to indicate this range, as in

THRU is a COBOL reserved word. VALID-GRADE is a condition-name that is met if GRADE has any of the values 'A', 'B', 'C', 'D', or 'F'.

Consider another example.

The condition-name VALID-YEAR is true if YEAR-OF-TRANSACTION, the field directly preceding it, has any value from 1999 to 2005, inclusive of the end points 1999 and 2005. Similarly, the statement IF NOT VALID-YEAR PERFORM 280-ERROR-IN-YEAR-RTN will cause 280-ERROR-IN-YEAR-RTN to be performed if YEAR-OF-TRANSACTION is less than 1999 or greater than 2005.

VALUE ALL may be used to specify repeated entries for a literal, like this:

If CODE-1 = 'AAAAA' then the condition CODE-ON will be met.

VALUE ALL could also be used to initialize the field itself, as in this example:

05 LITERAL-1 PIC X(10) VALUE ALL 'AB'.

LITERAL-1 will contain ABABABABAB.

Condition-names are frequently used for indicating when an AT END condition has been reached, as in

One function of the SET statement is to set a condition-name to TRUE. Consider the following SET statement.

SET NO-MORE-RECORDS TO TRUE.

When this format of the SET statement is executed, the value NO associated with the condition-name NO-MORE-RECORDS is placed in its conditional variable ARE-THERE-MORE-RECORDS, according to the rules of the VALUE clause. Thus, when SET NO-MORE-RECORDS to TRUE is executed, the value 'NO ' is placed in the conditional variable ARE-THERE-MORE-RECORDS. If multiple condition-names are specified, only one condition-name can be TRUE at one time.

This case problem illustrates the use of the IF and EVALUATE statements. The Payroll Manager of the Best Deal Stores Company needs an Employee Pay Report for all employees of the company.

The Systems Flowchart, Input Specifications for the Employee Pay File, and Output Specifications showing the layout of the report to be produced, are illustrated here:

Systems flowchart

Record description layout for employee pay file—EMPPAYPF

Calculations to be Performed:

Bonus is calculated as follows.

Gross Pay = Hours Worked * Hourly Rate + Bonus.

Federal Tax Rate: If Gross Pay is equal to or exceeds $50,000, Federal Tax equals a flat tax of 22 percent.

If Gross Pay is less than $50,000, Federal Tax equals a flat tax of 14 percent.

State Tax Rate: If Gross Pay is equal to or exceeds $75,000, State Tax equals a flat tax of 12 percent.

If Gross Pay is between $50,000 and $75,000, State Tax equals a flat tax of 9 percent.

If Gross Pay is between $25,000 and $50,000, State Tax equals a flat tax of 6 percent.

If Gross Pay is less than $25,000, State Tax equals a flat tax of 3 percent.

Pension Plan Contribution = Gross Pay * 7.5 percent.

Health Insurance Contribution is $10.50 for every employee.

Life Insurance Contribution: If Gross Pay exceeds $50,000, the employee portion of the Life Insurance Contribution is 1.5 percent of Gross Pay over $45,000.

Total Tax = Federal Tax + State Tax.

Total Deductions = Pension Plan Contribution + Health Insurance Contribution + Life Insurance Contribution + Total Tax.

Net Pay = Gross Pay - Total Deductions.

Printer spacing chart for Employee Gross Pay report

Figure 8.3. Solution for program CPCH08A.

Figure 8.4. Report produced from program CPCH08A.

Systems flowchart

Record description layout for student GPA file

Class Codes

1 = Freshman

2 = Sophomore

3 = Junior

4 = Senior

School Codes

1 = Business

2 = Liberal Arts

3 = Technology

Printer spacing chart for student GPA summary report