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 11 Advanced Perform Statements

Image

In Hour 10, “Processing Loops,” you learned the basic format for the Perform statement. In this hour, among other things you learn some more advanced methods of using Perform, such as

• Using inline Perform statements

• Using Perform with Varying

• Testing before and after the Perform

• Nesting Perform statements

• Compiling and linking a program for use with the interactive debug utility

Several other ways to use Perform make it a very powerful looping tool. In addition to the previously discussed methods of using Perform, you may code what is called an inline Perform. In this type of Perform, the lines of code that are to be performed are located immediately after the Perform verb and not elsewhere in the program. You may have a Perform adjust a numeric field up or down by a specified amount as it executes. Instead of the default behavior of testing for your condition before the Perform is executed, you can have the Perform statement make the test after the Perform.

Perform with Varying When Varying is used with the Perform statement, a numeric data item is specified. This item will be incremented by the value specified in a second data item or literal each time the Perform is executed. The starting value of the field before the increment is also specified. If you want the count down, you can vary the data item by a negative number. When Varying is used, the test for terminating the Perform is usually, but not always, based on the data item that is being varied. This feature is used often when working with tables. (Tables are discussed in detail in Hour 12, “Tables.”)

When using Varying, the field being varied is incremented after the Perform is executed. The test for the condition that terminates the Perform, specified by the Until phrase, is made before the Perform is executed.

In Listing 11.1, a field is incremented from 0 by 1 until that field is greater than 10. In this case, the computer counts from 1 to 10.

Listing 11.1 Count To 10

000001 @OPTIONS MAIN 000002 Identification Division. 000003 Program-Id. Chapt11a. 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 Counter Pic 9(2) value zeros. 000011 Procedure Division. 000012 Chapt11a-Start. 000013 Perform Count-Routine Varying Counter 000014 From 1 by 1 Until Counter > 10 000015 Stop Run 000016 . 000017 Count-Routine. 000018 Display Counter 000019 . When using Varying, you specify first the field you are going to adjust. The next item, after the word From, is the starting value of the variable. The number or data item that follows the word By is the amount by which you want to adjust the data value for each execution of the Perform. Any condition may appear after the word Until. When that condition is true, the Perform stops looping.

Here are some important points to remember about using Varying: First, the initial execution of the Perform is made with the item you decide to vary set at the initial value as specified with the word From. At the end of the Perform, the counter is adjusted by the amount specified after the By. The condition is tested before the Perform is executed.

What if you wanted to count by fives? In that case you would just change the number or data item after the word From in the Perform statement. If you wanted to count down instead of up, you could vary from 10 by –1. This adds a negative 1 to the counter each time, which is the same as subtracting 1, thus counting down.

000015 Perform Count-Routine With Test After Varying Counter 000016 From 10 by -1 Until Counter = 1 This code displays 10, counts down until 1 is displayed, and then stops. The value in Counter when the routine is complete is 1.

Testing Before or After Notice that you Perform Until the counter is greater than 10. Why do you think you didn’t say Until Counter = 10? The reason is that the Perform is not executed if the condition is true. If you coded the Counter = 10 condition, the Perform would not execute when the counter’s value is 10 and the loop would stop after displaying 9. When using Varying this way and testing for a value, you need to remember that the counter you use will have been incremented to a value beyond that which you might expect.

COBOL provides a way around this problem. Instead of the default behavior of testing for the condition before the Perform is executed, you can code With Test After. This option causes the Perform to test the condition immediately after the Perform has been executed and before any adjustment is made by the use of Varying. This approach ensures that you can use more understandable looping parameters. It also guarantees that the Perform will be executed at least once because the condition is not tested until after the Perform has executed. Listing 11.2 revisits the code from Listing 11.1, this time coded With Test After.

Listing 11.2 Count To 10, Revised

000001 @OPTIONS MAIN 000002 Identification Division. 000003 Program-Id. Chapt11a. 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 Counter Pic 9(2) value zeros. 000011 Procedure Division. 000012 Chapt11a-Start. 000013 Perform Count-Routine With Test After Varying Counter 000014 From 1 by 1 Until Counter = 10 000015 Stop Run 000016 . 000017 Count-Routine. 000018 Display Counter 000019 . The With Test After is coded following the Paragraph to be performed. If you want to make sure you know which method is being used—the default test before the Perform or the Test After—you may also code With Test Before.

Image

These examples use numeric literals for the starting value and increment. You may also use numeric data items for each of these.

The Use of the Inline Perform Having Perform statements that execute different Paragraphs is an excellent way to maintain a structured programming design. However, even these statements can be hard to follow. If you want to find out what is happening in a Perform, you have to jump to the portion of your source code where the Paragraph being performed is coded. Then you have to jump back to the place in your source code where the Perform statement is coded. This approach can be time-consuming and can easily lead you to lose your train of thought. COBOL allows you to have the best of both worlds. You can have a structured program, performing separate tasks, without having to search through your source every time you want to find what is happening inside a performed Paragraph. This technique uses an inline Perform.

Image

The inline Perform has all of the characteristics of a regular Perform with two exceptions. First, it is always terminated with the explicit scope terminator, End-Perform. Second, it has no Paragraph or Section name to be performed. The statements that are to be performed are coded between the Perform statement and the End-Perform explicit scope terminator.

The next bit of code modifies the program shown in Listing 11.2. Instead of performing the single-line Count-Routine, the following code uses an inline Perform.

000013 Perform With Test After Varying Counter 000014 From 1 by 1 Until Counter = 10 000017 Display Counter 000015 End-Perform How do you decide when to use an inline Perform instead of performing a Paragraph? Here are some very general guidelines. Each programmer has a different style of programming. Programming is sometimes a matter of style and sometimes a question of which method is easier for you to understand and follow.

• If only one or two statements are being executed, use an inline Perform.

• If you are using this code in only one place in the program, use an inline Perform.

• If the code can be reused and is performed from more than one place in the program, Perform a Paragraph instead. If you end up coding exactly the same statements inside two inline Performs, you should use a common Paragraph instead.

• If the Perform is heavily nested or takes up several pages of source code, you might want to break it down into individual paragraphs. Page after page of inline Perform code can be as hard or harder to follow than separated paragraphs.

The next example considers a more complex inline Perform and one of the many tasks that can be accomplished. What if you want to string two names together, but you don’t want any extra space between the names? You might have a First-Name field that is 20 characters long and a Last-Name field that is 20 characters long that you want to put together in one field. You can’t use the String statement, because the first name might contain embedded spaces. You really need to know the actual length of the name in the First-Name field.

One technique is to look at each character of the field until you find the end of the field. However, if embedded blanks are present, as in a name such as Daisy Mae, how do you find the end? The answer is to search from the end of the field toward the front looking for any character with a value greater than spaces. The program in Listing 11.3 accepts two names and creates one as the result. Each name may contain embedded spaces.

Listing 11.3 Inline Perform Example, Name Join

000001 @OPTIONS MAIN 000002 Identification Division. 000003 Program-Id. Chapt11b. 000004* Inline Perform Example, name join 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 Last-Name Pic X(20) Value Spaces. 000012 01 First-Name Pic X(20) Value Spaces. 000013 01 Combined-Name Pic X(40) Value Spaces. 000014 01 Name-Length Pic 99 Value Zeros. 000015 Screen Section. 000016 01 Name-Entry Blank Screen. 000017 03 Line 01 Column 01 Value “ Last Name: ”. 000018 03 Line 01 Column 13 Pic X(20) Using Last-Name. 000019 03 Line 03 Column 01 Value “First Name: ”. 000020 03 Line 03 Column 13 Pic X(20) Using First-Name. 000021 03 Line 05 Column 01 Value “ Full Name: ”. 000022 03 Line 05 Column 13 Pic X(40) From Combined-Name. 000023 Procedure Division. 000024 Chapt11b-Start. 000025 Display Name-Entry 000026 Accept Name-Entry 000027 Perform Varying Name-Length from 20 By -1 000028 Until First-Name (Name-Length:1) > Space 000029 or Name-Length = Zeros 000030 Continue 000031 End-Perform 000032 If Name-Length = Zeros 000033 Move Last-Name to Combined-Name 000034 Else 000035 String First-Name (1:Name-Length) 000036 Space 000037 Last-Name 000038 Delimited by Size 000039 Into Combined-Name 000040 End-If 000041 Display Name-Entry 000042 Stop Run 000043 . Examine the Perform statement that starts in line 27. It uses a numeric data item called Name-Length to hold the value of Varying. This code does not use Test After, because you are starting with a value of 20. If the field is full, then the Perform is not executed the first time through and 20 remains in the Length field for the next step.

Notice the complex condition for termination of the Perform. You want the Perform to stop when it finds a character that is greater than a space. The code uses reference modification to examine the field contents one character at a time. Reaching zero means that there are no characters greater than a space, and the field is empty. The Perform is not executed when the Name-Length field is zeros. This is essential, because testing the zero offset with reference modification is invalid.

When the Perform is complete, the Name-Length field contains the length of the first name that the user entered. If no first name is entered, there is no need to even try to construct a full name. The If statement in line 32 checks for this condition. If there is no first name, then the last name is just moved into the Combined-Name field. However, if there is something in the first name, the String statement in line 35 takes care of assembling the name. Only the portion of the First-Name field that is occupied by the first name the user entered is used, along with a space, and the last name.

Make a special note of the Continue statement used in the inline Perform. A statement must occur within the Perform. Because the Perform is actually accomplishing all the necessary testing and data manipulation, nothing actually happens inside the Perform. The Continue statement does nothing and is coded just to satisfy the compiler requirement that the inline Perform contain at least one statement.

Nesting Perform Statements You already know that you can Perform another Paragraph inside a Paragraph that is being performed. These multiple Perform statements can get confusing, especially when the Paragraphs being performed are scattered throughout your source code. Inline Performs can be used inside these performed Paragraphs. Additionally, you may also nest inline Performs.

000050 Perform 10 Times 000051 Perform 20 Times 000052 Add 1 to Data-A 000053 End-Perform 000054 End-Perform 000055 . In this example, 1 is added to Data-A 200 times. The exterior Perform in line 50, performs the Perform in line 51 ten times, and this interior Perform adds 1 to Data-A 20 times.

Image

When nesting Performs, it is a good idea to keep the End-Perform explicit scope terminator lined up with the Perform statement. Doing so makes the source code much more readable and easier to follow. This alignment clearly shows when a nested inline Perform ends.

The Inline If Statement and Perform You can create complex processing loops using inline If statements with inline Perform statements. This technique can handle complex processing without having paragraphs in far-flung areas of your source code. As an example, Listing 11.4 combines some of the programs you have recently written. The new program Displays and Accepts a screen. It Accepts last name, first name and telephone number. You should format the number as before, using either 10 or 7 digits and using a proper edit pattern. In addition, however, you want to left-justify the user input for the names. If someone keys in names with leading spaces, you want the code to remove the spaces. All of this activity occurs in one paragraph but still maintains a structured design.

Listing 11.4 Inline Perform with Inline If Example

000001 @OPTIONS MAIN,TEST 000002 Identification Division. 000003 Program-Id. Chapt11c. 000004* Inline Perform With Inline If Example 000005 Environment Division. 000006 Configuration Section. 000007 Special-Names. 000008 Crt Status Is Keyboard-Status. 000009 Source-Computer. IBM-PC. 000010 Object-Computer. IBM-PC. 000011 Data Division. 000012 Working-Storage Section. 000013 01 Keyboard-Status. 000014 03 Accept-Status Pic 9. 000015 03 Function-Key Pic X. 000016 88 F1-Pressed Value X”01”. 000017 03 System-Use Pic X. 000018 01 Temp-Field Pic X(20) Value Spaces. 000019 01 Formatted-Number Pic X(14) Value “(XXX) XXX-XXXX”. 000020 01 Formatted-Alternate Pic X(8) Value “XXX-XXXX”. 000021 01 Name-Length Pic 99 Value Zeros. 000022 01 Counter Pic 99 Value Zeros. 000023 01 Input-Output-Fields. 000024 03 Last-Name Pic X(20) Value Spaces. 000025 03 First-Name Pic X(20) Value Spaces. 000026 03 Phone-Number Pic 9(10) Value Zeros. 000027 03 The-Edited-Number Pic X(14) Value Spaces. 000028 03 Combined-Name Pic X(40) Value Spaces. 000029 Screen Section. 000030 01 Phone-Entry Blank Screen. 000031 03 Line 01 Column 01 Value “ Enter Phone Number: ”. 000032 03 Line 01 Column 22 Pic Z(10) Using Phone-Number. 000033 03 Line 02 Column 01 Value “ Enter Last Name: ”. 000034 03 Line 02 Column 22 Pic X(20) Using Last-Name. 000035 03 Line 03 Column 01 Value “ Enter First Name: ”. 000036 03 Line 03 Column 22 Pic X(20) Using First-Name. 000037 03 Line 05 Column 01 Value “ Full Name: ”. 000038 03 Line 05 Column 22 Pic X(40) From Combined-Name. 000039 03 Line 07 Column 01 Value “Edited Phone Number: ”. 000040 03 Line 07 Column 22 Pic X(14) From The-Edited-Number. 000041 03 Line 20 Column 01 Value “Press F1 to Exit”. 000042 Procedure Division. 000043 Chapt11c-Start. 000044 Perform Until F1-Pressed 000045 Display Phone-Entry 000046 Accept Phone-Entry 000047* Prepare To Format The Numbers 000048 Move “(XXX) XXX-XXXX” To Formatted-Number 000049 Move “XXX-XXXX” To Formatted-Alternate 000050* Format Based On Size 000051 If Phone-Number > 9999999 000052 Inspect Formatted-Number 000053 Replacing First “XXX” By Phone-Number (1:3) 000054 First “XXX” By Phone-Number (4:3) 000055 First “XXXX” By Phone-Number (7:4) 000056 Move Formatted-Number To The-Edited-Number 000057 Else 000058 Inspect Formatted-Alternate 000059 Replacing First “XXX” By Phone-Number (4:3) 000060 First “XXXX” By Phone-Number (7:4) 000061 Move Formatted-Alternate To The-Edited-Number 000062 End-If 000063* Left Justify The First Name 000064* If It’s Blank It’s A Waste Of Time 000065 If First-Name > Spaces 000066 Perform Varying Counter From 1 By 1 Until 000067 First-Name (Counter:1) > Space 000068 Continue 000069 End-Perform 000070* Counter Contains The Starting Offset 000071 Move First-Name (Counter:) To Temp-Field 000072 Move Temp-Field To First-Name 000073 End-If 000074* Left Justify The Last Name 000075 If Last-Name > Spaces 000076 Perform Varying Counter From 1 By 1 Until 000077 Last-Name (Counter:1) > Space 000078 Continue 000079 End-Perform 000080 Move Last-Name (Counter:) To Temp-Field 000081 Move Temp-Field To Last-Name 000082 End-If 000083* Now Put Them Together 000084 Perform Varying Name-Length From 20 By -1 000085 Until First-Name (Name-Length:1) > Space 000086 Or Name-Length = Zeros 000087 Continue 000088 End-Perform 000089 If Name-Length = Zeros 000090 Move Last-Name To Combined-Name 000091 Else 000092 String First-Name (1:name-Length) 000093 Space 000094 Last-Name 000095 Delimited By Size 000096 Into Combined-Name 000097 End-If 000098* Now We Repeat 000099 End-Perform 000100 Stop Run 000101 . Line 44 starts the outermost Perform. All the logic inside will execute until the F1 key is pressed. After you Display and Accept the user input, you process the fields. First, the telephone number is processed in exactly the same manner as in the previous code example (Listing 11.3).

Image

The one new element of code introduced here is the left-justification routine. The example uses an inline Perform in line 182 to search for the first character of the input field that is greater than spaces. You don’t Perform the routine at all if the field has no data in it. When you know the offset of the first character, you move the data from that position to the end of the field into a temporary variable. This temporary field now contains the left-justified name. You then move the data back to its original field. The same routine is used for the last name.

Image

This move to the temporary field is probably unnecessary. Because COBOL moves alphanumeric data fields 1 byte at a time from left to right, you could move the field in place. Move First-Name (Counter:) to First-Name. I refer to this type of Move as a “stupid COBOL trick”. It’s pretty neat but also pretty dangerous. It works on every compiler I tried, but some vendor may implement the mechanics of the Move statement differently. This technique is something that is more clever than clear, and I don’t recommend using it.

Using the Debugger It might be interesting to be able to see exactly what is happening inside the program when you run this example. Most modern compilers include a tool called an interactive debugging utility. The debugger enables programmers to step through the program one statement at a time and examine the values of the data fields involved.

This kind of facility can be a very powerful tool when it comes to debugging your programs. As an example, try running Listing 11.4 in debugging mode with the Fujitsu compiler. If you are using a different compiler, you can look at your documentation for instructions on running a debug session.

First, you need to add a compiler option to the program. Change the options at the top of the program to read:

000001 @OPTIONS MAIN,TEST Compile the program with these options, but don’t link it. you also have to change some options on the link step.

Proceed with the link step as you normally would. Before clicking the Link button, click the Options button. On the Options window, click the Debug button. Click the OK button. Then click the Link button. After the program links, you are ready to run it in debug mode.

If you are running under Windows 3.1, proceed to the link step normally. Before clicking the Build button, select the Options menu option. Select the /CO check box and click the OK button. Click the Build button and then link the program in debug mode.

Select the Tools menu option (Under Windows 3.1, you want the Utilities menu). Choose WINSVD[Debug], click File, and then click Start Debugging. In the window that appears, click the Browse button. Choose Chapt011c and then click OK. Click the OK button to start the debug session. Click OK when the Runtime Options window appears. The screen shown in Figure 11.1 should appear.

The current source line is highlighted in yellow. You can do several things in debug mode. The right mouse button is active and provides quick access to many functions. To follow the program, however, click the Step Into button. This executes the highlighted line of source. Step into each source line until the Accept statement. When you step into it, the Step Into icon should be grayed out. You need to activate the screen window so that you can enter the required data.

Figure 11.1 Debug session opening screen.

Image

The Fujitsu debug facility under Windows 3.1 is very different from that provided for Windows NT and Windows 95/98. Follow these steps to start the debug session under Windows 3.1:

1. From Programming Staff, choose the Utilities menu option.

2. Choose the WINSVD selection.

3. When the Start Parameter screen appears, leave all the fields blank and click the OK button.

4. Select the \TYCOBOL folder from the Directories window.

5. Select the Chapt11c.exe program and click OK.

6. Click OK again on the Start Parameter screen.

7. When the Runtime Environment Setup appears, click the Run button.

8. The current source line is indicated by blue superimposed X characters over the active COBOL verb.

9. To step through the program, use the Step L button.

To activate the Screen window, click on the Screen item on the Windows taskbar. (Under Windows 3.1, use the ALT+TAB key combination to select SCREEN:CHAPT11C.) Key in the input data and space over a bit for each name so that you can see the left-justify routine in action.

As soon as you press Enter, the debug screen is displayed again. Use the Step Into button and step to the first If statement. Before it is executed, position the mouse pointer over the Phone-Number field and click the right mouse button. (Under Windows 3.1, select the Data then Data Control menu options. You have to key the name of the field you want to view in the Data input field. Then click OK to view the field contents.) From the pop-up menu, choose the Data menu option. A new window displays the length, format, and value of data field you selected. If you want to see the internal representation of the data value, you may select the Hex radio button. (Under Windows 3.1, use the Change Format button from the Data Control window.) The data value is displayed in hexadecimal notation. To modify a data value, you can key over it and then select the Modify button. Doing so will allow you to test the program action when a field contains specific data.

Close the data window. Use the Step Into button until you get to the next Perform statement. Because this Performs no statements, the active line remains the End-Perform until the test condition is satisfied.

Use the scroll bar to scroll down to the If statement at line 89. Position the mouse over this line, click the right mouse button, and choose Set Breakpoint. (Under Windows 3.1, use the Break menu option followed by the Set Breakpoint selection.) The selected line turns red. A breakpoint tells the debugger where to stop while executing. You don’t have to step through every instruction in the program. You can now click the Go icon. (Under Windows 3.1, choose the Runto menu option and then select Run.) The debugger stops on the line you have set for a breakpoint.

Another interesting option is Animate. (Under Windows 3.1, use the Runto menu option and then select Trace.) This option enables you to watch the program step through its instructions. It stops on any statements requiring user input or on any breakpoints that have been set. When user input is accepted and Animate is enabled, you have to use the taskbar to return the focus to the debugging window. The debugging window does not automatically appear. While animating, the debugger stops on the last statement prior to a breakpoint. To step into that breakpoint, click the Breakpoint icon, which will be enabled.

Continue experimenting with the debugging session. Close the debugger when you are finished.

Summary In this hour, you learned the following:

• How to use the Perform option Varying to set a counter, increment it by a specified amount for each execution, and stop when the specified condition is reached.

• How to use Test After to change the behavior of the condition testing in a Perform statement. Normally, your condition is tested before the statements after the Perform are executed. Using Test After guarantees at least one execution of the Perform.

• How to place your program statements between a Perform statement and the End-Perform explicit scope terminator, creating an inline Perform, instead of performing Paragraphs or Sections.

• How to nest Perform statements and include complex If logic, even when using the inline Perform. This approach maintains program design structure, but the statements are not scattered about your source code.

• How to compile and link a program for use with the interactive debugger. You found out how to use the debugger and to follow what is happening inside a program.

Q&A Q When I use the Varying statement, does the data item I am incrementing have to be initialized to any particular value?

A No. The word From in the Perform statement specifies the starting value of the data item. Its value before the Perform does not matter.

Q I am confused about when I should use an inline Perform versus performing a Paragraph. Can you give me some insight?

A The decision on using an inline Perform instead of an out-of-line Perform is basically a matter of style. Some people prefer inline Performs, and some do not. The inline Perform is particularly useful for tasks like the left-justify procedure used Listing 11.4. If you have programming statements that are repeated in several inline Perform statements, you might want to change these to be distinct Paragraphs.

Q When I nest a Perform within an inline Perform, can I Perform a Paragraph, or must all the Performs be inline?

A You may Perform a Paragraph or Section. The inline Perform allows you to use any valid COBOL statements, which includes performing Paragraphs.

Q What should I watch for when using an inline Perform?

A You should never use a Go To to exit the inline Perform. In addition, you must be very careful not to terminate any statements inside the Perform, with a period. Use the End-If explicit scope terminator with every If statement you code inside the inline Perform. You should also use caution not to Perform the paragraph that contains the inline Perform, from within that inline Perform.

Q When I try to debug my program, what should I do if the debugging screen does not appear?

A Make sure you have compiled your program with the TEST compiler option. Then make sure you have chosen the Debug option when linking the program. (Under Windows 3.1, use the /CO option.)

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)