https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Return to Teach Yourself COBOL in 24 Hours, COBOL bibliography, COBOL, COBOL DevOps, Awesome COBOL, Awesome IBM Mainframe, IBM Mainframe development, IBM Mainframe bibliography, Fortran

“ (TYCb24H 1998)

Hour 8 Conditional Statements

Computer programs can perform tasks that range from very simple to very complex. More complicated tasks require making choices. Under some circumstances, you might want the program to perform one function; but under other circumstances, you might desire a different function. Conditional statements perform the act of choosing the appropriate function. A conditional is the statement or question asked in order to make a choice. It is somewhat like a question you might ask yourself, for example, “If I have enough money, can I buy an ice cream sundae?” In this hour, you learn about the various types of conditional statements available in COBOL, such as

• The If statement.

• Various conditions that can be tested using If.

• The Else clause

• Evaluating complex conditions

• 88 levels and how they relate to conditions.

Conditional Statements in COBOL Conditional statements control the flow of a program. For the most part, the examples that have been examined thus far involved statements that were always executed. With conditional statements, you can decide which statements to execute under different conditions. For example, if the user can enter multiple types of transactions, you need the program to decide the appropriate action to take based on the type of transaction. A debit transaction cannot be processed the same way as a credit transaction. Conditional statements are coded to tell the program what to do when various conditions are encountered.

You have already seen some conditional statements in action. The Size Error phrase that can be coded with mathematical statements is one example. When a Size Error occurs, the statements coded with the Size Error phrase are executed. The Size Error is the condition under which the statements are executed. It is similar to stating, “Do the add operation; then if there is a size error, do something special.”

The If Statement The If statement is the most fundamental of the COBOL conditional statements. With the If statement, you tell the program to make a simple choice. If the condition stated is true, then do what is specified. It is in stating these conditions that an infinite variety of possibilities is found. COBOL allows you much freedom in the coding of conditional statements. They can be as simple or complex as you allow them to be. These conditional statements are at the heart of computer programming.

When you code an If statement and the condition tested is true, every statement after the If is executed until an End-If, Else, or period is encountered. (Else is discussed in the next section; for now concentrate on the different conditions.)

The If statement can be used to test the relationship between two or more data items. When two data items are compared, one of three things can be determined:

• The data items are equal.

• The first data item is greater in value than the second.

• The second data item is greater in value than the first.

When writing your conditional statement, you are asking if one or more of these three conditions is true. If the condition is true, then the If statement is considered to be true.

Image

As I look over my programming career, I find that two courses I took in school contributed most to my success. One is typing. The second, and more important, is a course I took in symbolic logic. I cannot overstress the value of such a course to the computer programmer. If your local community college offers such a course, and you are serious about computer programming in any language, take this course.

The simplest condition is the test for equality. This test can be coded in two ways. You may use the = sign, or you may spell out Is Equal To. The words, Is and To are optional. Table 8.1 shows a few examples of tests for equality and whether or not they are true.

Table 8.1 Testing the Equality Condition

Image

To properly understand equality, you need to understand how the different data items are compared. Different types of data items are compared differently.

Alphanumeric data items and literals are compared from left to right, character by character. Trailing spaces in an alphanumeric data item do not affect the comparison. “A” is the same as “A ”. The compiler pads the shorter field with trailing spaces to make the fields of equal length for the comparison.

Numeric fields are compared based on their values. If a field defined as having one decimal position is compared to a field having three and the numeric values are equal, the condition is true.

Numeric items may be compared with numeric expressions. That is, you may perform tests that compare 1 and (3–2). The expressions are evaluated before the comparison is made.

When numeric and alphanumeric items are compared, the comparison proceeds as if it were an alphanumeric compare.

Numeric edited items are treated as alphanumeric items for the purpose of comparisons.

The If statement tests the truth of these conditions. If the test is true, then the statements following the If are executed. If the test is false, the statements are not executed. Consider some examples. For clarity, these use numeric variables and expressions for comparison.

000027 If 1 = 12 000028 Display “Condition True” 000029 End-If This condition is false, because 1 is not equal to 12. The Display statement is not executed. The End-If is an explicit scope terminator that terminates the If statement. Flow through the program continues immediately following this End-If.

Image

An If statement may also be terminated with a period. The preceding example could have been coded: If 1 = 12, Display “Condition True”. However, for the structured programming style used in these lessons, only one period per paragraph is used. The End-If signifies the end of the statements to be executed if the condition being tested is true.

More than one statement may be executed after an If statement’s condition is determined to be true.

000030 If Data-Item-1 = Data-Item-2 000031 Display “The Data Items are The Same” 000032 Unstring Data-Item-1 000033 Delimited By Space 000034 Into Unstring-Field-1 000035 Unstring-Field-2 000036 End-Unstring 000037 End-If In this example, if the values of Data-Item-1 and Data-Item-2 are true, then two COBOL statements are executed. The first displays a literal, and the second performs an Unstring operation. Neither of the statements is executed if the condition is false, that is, if Data-Item-1 and Data-Item-2 are not equal. However, if the condition is true, both statements are executed.

In addition to testing for equality, you may test for inequality. There are two ways to express the condition. You may code Not Equal or Not =. The condition is tested, and if true, that is, the data items compared are not the same, then the statements following the If are executed.

Image

The If statement may be coded with the word Then. Using Then does nothing special as far as evaluating the If statement, but it can clarify the If logic, making it a bit easier to understand. For example, you could code: If 1 = 12 Then … This method is often easier to follow at first. After you are more comfortable with the If statement, you may find that the word Then is simply extra typing.

The next condition type is a test to compare the value of two data items to determine whether the first item is less than the second. Less than is pretty easy to understand when discussing numbers. It is obvious that 1 is less than 10. What can be confusing is alphanumeric data items in conditions. Can you see why “Four” is less than “One”?

The testing of relative values of alphanumeric data items is controlled by the collating sequence of the computer’s character set. A character set is simply the group of characters that the computer understands. For the PC, this character set is called the ASCII character set. This character set consists of 256 characters. Each character has a ranking within that set. The character with the lowest ranking is less than one with a higher ranking in any condition.

Image

The characters might not compare the way you might expect. Within the alphabet, “A” is less than “Z”, and “0” is less than “9”. However, a lowercase “a” is greater than an uppercase “Z”. The characters “A” and “a” are separate and have different values within the ASCII collating sequence. You must use caution when comparing alphanumeric variables to ensure that you understand the potential results of your comparisons.

When two alphanumeric items are compared in a less-than condition, each character in each item is compared one at a time. The comparison proceeds from left to right. When the first character that determines the condition is either true or false is encountered, the comparison is terminated. When comparing “APPLE” and “ORANGE”, only a single character in each needs be compared to determine which is greater. When “ZZZZZT” and “ZZZZZP” are tested, seven characters must be compared before it is decided that “ZZZZZZP” is less than “ZZZZZZT”.

The less-than comparison may be coded as either < or Less Than. For example:

000038 If Data-A Is Less Than Data-B 000039 Display “A less than B” 000040 End-If is exactly the same as

000038 If Data-A < Data-B 000039 Display “A less than B” 000040 End-If The Is in the first example is optional. The condition is true only if Data-A is less than Data-B. If Data-A and Data-B are the same, or equal, the condition is not true. The opposite of Less Than is not Greater Than. Greater Than leaves out the potential for the items to compare equally. The opposite condition of Less Than is Greater Than Or Equal To. If you want to test whether Data-A is not less than Data-B, code the following:

000041 If Data-A Not < Data-B 000042 Display “A not less than B” 000043 End-If In this case, if the values of Data-A and Data-B are the same, the condition is true. In other words, if the values of Data-A and Data-B are the same, then the value of Data-A is certainly not less than the value of Data-B!

The next condition is a test for whether the first variable is greater than the second. This test can be coded with > or Greater Than. If the two items being compared are equal, then the condition is false. The opposite condition may be tested by coding Not in front of the > symbol.

The Less Than and Greater Than conditions can be combined with the Equal. The combination is coded as ⇐ or Less Than Or Equal, and conversely, >= or Greater Than Or Equal. For the ⇐ condition, the condition is true if the first data item is either less than the second or the same as the second. These conditions are sometimes confusing. Here are some examples of If statements that use these conditions.

000044 If Data-A Not > Data-B 000045 Display “A < B” 000046 End-If 000047 If Data-B >= Data-A 000048 Display “B >= A” 000049 End-If These two If statements are different ways of coding exactly the same thing. Plug in various values for Data-A and Data-B and see that both conditions are true when the same values for Data-A and Data-B are inserted. Using >= and ⇐ is a way to avoid using the Not, which some people find confusing.

Literals may be used in conditions. For example, you can test whether Data-A is Greater Than Spaces.

In addition to comparing the values of data items, a condition can test the class of an item. This test determines whether the item is Numeric, Alphabetic, Alphabetic-Lowercase, Alphabetic-Uppercase, or some other special condition as provided for in the Special-Names paragraph by the compiler. You may specify Class in the Special-Names paragraph and create a new class based on a range of values. For example:

000008 Special-Names. 000009 Class ABC is “A” thru “C” 000010 Space. This Special-Names paragraph defines a new class named ABC, which consists of the letters A, B, and C and the space. You may test a field to determine whether it consists of these values by coding:

000100 If Test-Field ABC 000101 Display “Test-Field is of Class ABC” 000102 End-If If you have an alphanumeric data field that you need to move to a Usage Display numeric data item, you should test the field first to see whether it is numeric. Moving nonnumeric data into a numeric field can cause erroneous results or a program crash. This test may be coded as

000050 If Data-A Is Numeric 000051 Move Data-A To Number-A 000052 End-If The word Is in the expression is optional.

The Else Clause When coding your If statements, you may wish to do one thing if the condition is true but something else if the condition is false. This option is available to you by using the Else clause. When you code an If statement and use an Else clause, when the condition being tested is false, the statements after the Else are executed until an End-If or period is encountered.

000053 If Data-A < Data-B 000054 Display “A < B” 000055 Else 000056 Display “A not < B” 000057 End-If Image

Remember that the statements that are executed when the condition tested is true stop when the Else is encountered. If the condition is true, the statements after the Else are not executed. Terminating the If statement with the End-If explicit scope terminator or period is very important. You may find that many lines of your program are not being executed because they fall under an Else statement inside an If that was not properly terminated.

As with the If, multiple statements may be executed after the Else.

Using Complex Conditions If statements can test complex conditions. A complex condition is like a series of conditions combined into a single condition. Complex conditions are created by using And, Or, and Not.

When And is used, all conditions linked by the And must be true for the entire condition to be true. It is the true or false state of the entire condition that the If statement is testing. Consider an example:

000058 If Data-A = Data-B And Data-C = Data-D 000059 Display “Condition True” 000060 End-If In this example, the display only occurs if the values of Data-A and Data-B are the same and if the values of Data-C and Data-D are the same. For example, if Data-A has a value of 3, Data-B has a value of 3, Data-C has a value of 5, and Data-D has a value of 5, then the entire condition is true.

Image

You may use parentheses to isolate your conditions when using complex conditions. Parentheses help to clarify the individual conditions that make up your complex conditions. The preceding example could have been more clearly coded as If (Data-A = Data-B) And (Data-C = Data-D).

When Or is used, only a single one of the conditions being tested need be true for the entire complex condition to be true.

000058 If Data-A = Data-B Or Data-C = Data-D 000059 Display “Condition True” 000060 End-If In this case, if either Data-A = Data-B or Data-C = Data-D is true, then the entire condition is true and the Display statement is executed.

The word Not can be used to negate a condition. That is, for a condition preceded by Not to be true, the condition must be false. When using Not, it is useful to enclose the condition that is being negated in parentheses. Some examples can help to make this clear.

000061 If Not (Data-A = Data-B) 000062 Display “Condition True” 000063 End-If This condition first tests Data-A and Data-B for equality. If that condition is false, then the entire condition is true. It is exactly the same thing as stating If Data-A not = Data-B. The Not phrase can be very useful but also baffling. Using Not is very similar to using Else, except the statements normally coded under the Else are coded after the If statement instead. In the next example, the two If statements perform the same function.

000064 If Data-A = Data-B 000065 Display “A = B” 000066 Else 000067 Display “A not = B” 000068 End-If 000069 If Not (Data-A = Data-B) 000070 Display “A not = B” 000071 Else 000072 Display “A = B” 000073 End-If Using Not basically reverses the statements that are executed after the If and Else. If you want to avoid using Not, you can always code If statements with the Else clause. The only problem with this approach is what to do when you only have statements to execute under the Else clause. For this problem, COBOL provides the Continue statement.

Continue performs no activity and can be used as a nonoperational statement. It can be coded when the COBOL syntax requires a statement to be present, but you have nothing you want to do, as in this example:

000074 If Data-A = Data-B 000075 Continue 000076 Else 000077 Display “A not = B” 000078 End-If Complex conditions can be abbreviated, but you should be careful. The abbreviated version may be hard to grasp logically. The two If statements in the next example are the same. The second one is an abbreviated version of the first:

000079 If Data-A = Data-B Or Data-A = Data-C Or Data-A = Data-D 000080 Display “Condition is True” 000081 End-If 000082 If Data-A = Data-B Or Data-C Or Data-D 000083 Display “Condition is True” 000084 End-If The condition is abbreviated by removing the repeated data item.

Examine a variation on one of the examples previously discussed. In an earlier example, you were formatting a telephone number in the format (999) 999-9999. If the telephone number does not include the area code, you want to leave it off. Listing 8.1 is a small program that shows the use of an If statement to determine the proper formatting logic for the telephone number.

Listing 8.1 Intelligent Telephone Number Format

000000 @OPTIONS MAIN 000001 Identification Division. 000002 Program-Id. Chapt08a. 000003* Intelligent Telephone Number Format 000004 Environment Division. 000005 Configuration Section. 000006 Source-Computer. IBM-PC. 000007 Object-Computer. IBM-PC. 000008 Data Division. 000009 Working-Storage Section. 000010 01 Phone-Number pic 9(10) Value Zeros. 000011 01 Formatted-Number Pic X(14) Value “(XXX) XXX-XXXX”. 000012 01 Formatted-Alternate Pic X(8) Value “XXX-XXXX”. 000013 01 The-Edited-Number Pic X(14) Value Spaces. 000014 Screen Section. 000015 01 Phone-Entry Blank Screen. 000016 03 Line 01 Column 01 Value “ Enter Phone Number: ”. 000017 03 Line 01 Column 22 Pic Z(10) Using Phone-Number. 000018 03 Line 03 Column 01 Value “Edited Phone Number: ”. 000019 03 Line 03 Column 22 Pic X(14) From The-Edited-Number. 000020 Procedure Division. 000021 Chapt08a-Start. 000022 Display Phone-Entry 000023 Accept Phone-Entry 000024 If Phone-Number > 9999999 000025* Number large enough to contain area code 000026 Inspect Formatted-Number 000027 Replacing First “XXX” By Phone-Number (1:3) 000028 First “XXX” By Phone-Number (4:3) 000029 First “XXXX” By Phone-Number (7:4) 000030 Move Formatted-Number To The-Edited-Number 000031 Else 000032* Number not large enough to contain an area code 000033 Inspect Formatted-Alternate 000034 Replacing First “XXX” By Phone-Number (4:3) 000035 First “XXXX” By Phone-Number (7:4) 000036 Move Formatted-Alternate To The-Edited-Number 000037 End-If 000038 Display Phone-Entry 000039 Stop Run 000040 . This program has several interesting features. First, note that the If, Else, and End-If are aligned to make the code easier to follow. Notice also the use of reference modification in the Inspect statements. A numeric data item accepts the telephone number so that the value can be tested to see whether the number was keyed with an area code. Additionally, using a numeric data field causes the number to be right-justified. This technique allows you to know where the specific portions of the telephone number are so that you may use reference modification. The If statement is used with an Else clause to determine which of the Inspect and Move statements to execute.

Key the program into the editor. Then compile, link, and run the program. Experiment with inputting different telephone numbers, and view the results.

Nesting If Statements Image

If statements may be nested. That is, after the condition, or the Else, another If statement can occur. One case in which nesting might be useful is when a variable could have three possible values that you need to test.

000085 If Data-Item-1 = “A” 000086 Display “Apple” 000087 Else 000088 If Data-Item-1 = “B” 000089 Display “Berry” 000090 Else 000091 Display “Chocolate” 000092 End-if 000093 End-if After the Else associated with the test for “A”, there is another condition, testing for “B”. You can nest If statements up to the limit of the compiler. Different compilers allow a different number of levels of nesting.

Image

When coding nested If statements, it is a good idea to always make use of the End-If explicit scope terminator. Your source code will be easier to follow if you align your If, Else, and associated End-If statements. Hour 9, “The Evaluate Statement,” and later hours describe alternatives to deeply nesting If statements.

88 Levels and the Set Statement Image

In the Data Division, you may define a special level numbered item called a condition name. This condition name can be tested as a condition. Condition names may be associated with any elementary data item including a Filler data item. Another commonly used term to describe these condition names is flag. In your program, if you want to perform a special operation, you might set a flag. For example, after reading the last item from a file, you might set a flag to indicate that the entire file has been read. Later in the program, you can test that flag to determine when to stop processing.

Condition names are defined by coding an 88 level with the condition name and the value or values that cause the condition to be true.

000020 01 Flag-Variable Pic X. 000021 88 Flag-On Value “1”. The condition Flag-On is true when Flag-Variable has a value of 1. You may code as many 88 levels under a data item as you want. Additionally, an 88 level may specify a range of values or even multiple ranges. If the data item that the condition name is coded for is equal to any of the values, then the condition is true.

000022 01 Data-Flags. 000023 03 Filler Pic X(3) Value Spaces. 000024 88 Test-One Value “ONE” “one” “One”. 000025 88 Test-Two Value “TWO” “two” “Two”. 000026 03 Filler Pic X Value Spaces. 000027 88 A-Thru-Z Value “A” Thru “Z”. 000028 88 0-Thru-9 Value “0” Thru “9”. 000029 03 Number-Flag Pic 9. 000030 88 Low-Number Value 0 Thru 4. Test-One is true when the value of the three-character Filler is equal to one of the three values defined. The condition A-Thru-Z is true when the Filler item has a value of any letter between “A” and “Z”.

Because you cannot move a value directly into a Filler item, you might be curious as to how the condition can become true. Consider this example:

000031 01 Filler Pic X. 000032 88 Letter-A Value “A”. You cannot move a value into the Filler or into the condition name Letter-A. However, with COBOL you can use the Set verb to set a condition name to a true state. When you code the statement, Set Letter-A To True, an A is moved into the Filler item and the condition is true. Using Set is a good way to control the state of conditions.

Image

Presently in COBOL, there is no way to “unset” a condition, or to set a condition to false. In the preceding example, when an A gets into the Filler item, there is no way to get it out. When using conditions with Filler items, you should always allow for a second 88 level item that has a different state. For example, in the preceding example you could code another 88 level with a condition name of Space-Item, and then using the Set statement, set that condition true.

   000031 01 Filler Pic X.
   000032    88 Letter-A    Value “A”.
   000033    88 Space-Item  Value Space.

When Space-Item becomes true, a space is moved into the Filler. If you have conditions that you need to set and reset in your program, you should assign a variable name instead of using Filler so that you may either use Initialize, or move a value directly into the field.

Using 88 Levels in an If Statement Condition names, or 88 level items, may be used with an If statement. If the condition name is true, then the statements after the If are executed. To illustrate, look at Listing 8.2. This program unstrings a name entry into three fields. Then, depending on the number of names entered, the code moves the data field to the appropriate name for display.

Listing 8.2 Intelligent Name Separation

000001 @OPTIONS MAIN 000002 Identification Division. 000003 Program-Id. Chapt08b. 000004* Intelligent Name Separation 000005 Environment Division. 000006 Configuration Section. 000007 Source-Computer. IBM-PC. 000008 Object-Computer. IBM-PC. 000009 Data Division. 000010 Working-Storage Section. 000011 01 Name-Entered Pic X(50) Value Spaces. 000012 01 First-Name Pic X(30) Value Spaces. 000013 01 Middle-Name Pic X(30) Value Spaces. 000014 01 Last-Name Pic X(30) Value Spaces. 000015 01 Unstring-Fields Value Spaces. 000016 03 First-Field Pic X(30). 000017 03 Second-Field Pic X(30). 000018 03 Third-Field Pic X(30). 000019 01 Number-Of-Fields Pic 9 Value Zeros. 000020 88 Last-Name-Only Value 1. 000021 88 First-And-Last Value 2. 000022 88 First-Last-Middle Value 3. 000023 Screen Section. 000024 01 Name-Entry Blank Screen. 000025 03 Line 01 Column 01 Value “Enter Name: ”. 000026 03 Line 01 Column 13 Pic X(50) Using Name-Entered. 000027 03 Line 03 Column 01 Value “ First: ”. 000028 03 Line 03 Column 09 Pic X(30) From First-Name. 000029 03 Line 04 Column 01 Value “Middle: ”. 000030 03 Line 04 Column 09 Pic X(30) From Middle-Name. 000031 03 Line 05 Column 01 Value “ Last: ”. 000032 03 Line 05 Column 09 Pic X(30) From Last-Name. 000033 Procedure Division. 000034 Chapt08b-Start. 000035 Display Name-Entry 000036 Accept Name-Entry 000037* Unstring into possible 3 fields, allow for multiple spaces 000038* between names 000039 Unstring Name-Entered Delimited By All Space 000040 Into First-Field, Second-Field, Third-Field 000041 Tallying In Number-Of-Fields 000042 End-Unstring 000043* Now, move as appropriate. 000044 If Last-Name-Only 000045 Move First-Field To Last-Name 000046 End-If 000047 If First-And-Last 000048 Move First-Field To First-Name 000049 Move Second-Field To Last-Name 000050 End-If 000051 If First-Last-Middle 000052 Move First-Field To First-Name 000053 Move Second-Field To Middle-Name 000054 Move Third-Field To Last-Name 000055 End-If 000056 Display Name-Entry 000057 Stop Run 000058 . Number-Of-Fields is the field that contains the number of fields that are changed when the Unstring statement is executed. Under that field, three conditions are defined. Then three If statements follow the Unstring. Notice how much easier the statements are to understand when the conditions are spelled out with condition names. The If statements can be coded as If Number-Of-Fields = 1 and so on, but that is not nearly so clear.

Summary In this hour, you learned the following:

• Conditions can be tested to cause the COBOL program to execute different instructions under different circumstances.

• You can test two data items for equality or to determine which of the two is greater.

• The collating sequence controls how alphanumeric data items are compared.

• You can use And, Or, and Not to create complex conditional statements.

• The If statement can test these various conditions.

• Else can execute different statements if a condition is not true.

• The Continue statement can be used when a statement is required, but you want the program to perform no action.

• If statements can be nested.

• Condition names can be defined in the Data Division and then tested in your program.

Q&A Q What is the purpose of the If statement?

A The If statement allows the programmer to test for certain conditions and to perform different statements based on the results of those tests.

Q When creating a complex condition using Or, what determines whether the entire condition is true?

A When using an Or, if one of the conditions coded is true, then the entire complex condition is true. You may code a string of Or conditions, and if any one of them is true, then the entire condition is true.

Q Can I use And and Or in the same condition?

A Yes. You can code something like, If A = 1 and B = 1 or C = 1. However, this syntax is hard to understand. It is better to code this condition as follows: If (A = 1 And B = 1) Or C = 1. When this statement is tested, the condition is true if A and B are both 1, or if C is 1 regardless of the values in A and B.

Q Can I code an If statement under another If statement?

A Yes. These statements are called nested If statements.

Q How do I make a condition name defined with an 88 level true?

A You can do so in two ways. Either you can move the appropriate value into the elementary item with which the condition name is associated, or you can use the Set statement to set the condition to the true state.

Workshop To help reinforce your understanding of the material presented in this hour, refer to the section “Quiz and Exercise Questions and Answers” that can be found on the CD. This section contains quiz questions and exercises for you to complete, as well as the corresponding answers.

Fair Use Sources:

• B001FWIJGE (TYCb24H 1998)