RDz Workbench – Debugging z/OS COBOL Applications

RDz Workbench – Debugging z/OS COBOL Applications
Jon Sayles, Rational System z Products -

IBM Trademarks and Copyrights
Developing COBOL with IBM WebSphere Developer for zSeries IBM Trademarks and Copyrights © Copyright IBM Corporation 2007,2008, 2009, 2010, 2011, 2012, All rights reserved. The information contained in these materials is provided for informational purposes only, and is provided AS IS without warranty of any kind, express or implied. IBM shall not be responsible for any damages arising out of the use of, or otherwise related to, these materials. Nothing contained in these materials is intended to, nor shall have the effect of, creating any warranties or representations from IBM or its suppliers or licensors, or altering the terms and conditions of the applicable license agreement governing the use of IBM software. References in these materials to IBM products, programs, or services do not imply that they will be available in all countries in which IBM operates. This information is based on current IBM product plans and strategy, which are subject to change by IBM without notice. Product release dates and/or capabilities referenced in these materials may change at any time at IBM’s sole discretion based on market opportunities or other factors, and are not intended to be a commitment to future product or feature availability in any way. IBM, the IBM logo, the on-demand business logo, Rational, the Rational logo, and other IBM Rational products and services are trademarks or registered trademarks of the International Business Machines Corporation, in the United States, other countries or both. Other company, product, or service names may be trademarks or service marks of others. Module 6 - Debugging COBOL programs

Course Contributing Authors
Developing COBOL with IBM WebSphere Developer for zSeries Course Contributing Authors Thanks to the following individuals, for assisting with this course: Russ Courtney/IBM Reginaldo Barosa/IBM David Bean/IBM-Rational Sihab Kolaparambil/Wipro Vinay Varanasi/Capgemini Cindy Krauss/IBM Vikram Manchala/IBM Module 6 - Debugging COBOL programs

Developing COBOL with IBM WebSphere Developer for zSeries
Course Overview Audience This course is designed for application developers who have learned or programmed in COBOL, and who need to do z/OS Traditional Development and Maintenance as well as build leading-edge applications using COBOL and Rational Developer for System z. Prerequisites This course assumes that the student has a basic understanding and knowledge of software computing technologies, and general data processing terms, concepts and vocabulary, as well as a working knowledge of COBOL and z/OS. Knowledge of SQL (Structured Query Language) is assumed for database access is assumed as well. Basic PC and mouse-driven development skills, terms and concepts are also assumed. Module 6 - Debugging COBOL programs

Course Topics Course Name: Rational Developer for System z Foundation Training Course Description: Learn how to use Rational Developer for System z to do z/OS traditional development, maintenance, support and for Enterprise Modernization of z/OS applications Pre-requisites: Some experience developing COBOL applications using z/OS is expected. A working knowledge of SQL is also recommended. Course Length: ~5days – or if done in self-paced mode, at your own pace Topics (Agenda) Getting Started - installing and configuring RDz - and the course materials, and using Eclipse The RDz Workbench Code analysis tools Editing Compiling programs Debugging local COBOL programs The Data Perspective: Working with relational data sources Modifying test data Editing and testing SQL statements Working with remote system resources: Connecting to a mainframe Data management Accessing and editing files z/OS Application Development Creating MVS Subprojects Creating and customizing project properties Debugging z/OS Applications Debugging Batch Applications Setting Debug Tool for Online Applications Working with File Manager Creating test data Editing complex file-types Working with mainframe ABENDs using Fault Analyzer Creating Fault History views Analyzing and solving mainframe ABENDs Creating and modifying BMS Maps using the BMS Map Editor Module 6 - Debugging COBOL programs

The RDz Workbench UNIT Topics: Debugging z/OS COBOL Batch Applications
Debugging z/OS COBOL Online Applications Appendix

Topic Considerations  Note: In this topic you will learn how to debug a COBOL program running on a z/OS mainframe. The screen captures all describe connecting to a public z/OS machine that IBM makes available – during classes. If you are taking this course through standard IBM services delivery you should be able to use the properties (I/P address, port#s, etc.), logon IDs and passwords that your instructor provides you with. But you may also be taking this course standalone – and in that case, you will need to speak to your company's Systems Programming staff to learn how to connect and logon. It goes without saying that the actual file names in the screen captures of mainframe libraries and datasets will vary. So you should focus on the process and steps and "how to" – and don't be perplexed at differences in screen captures. You also may be using your company's own Source Control Management system – to do things like builds, compiles, etc. In that case much of the remote functionality in RDz will be customized and tailored to your company's unique and idiosyncratic procedures and protocols. Module 6 - Debugging COBOL programs

Workshop Considerations
Developing COBOL with IBM WebSphere Developer for zSeries Workshop Considerations  Note: Unfortunately, due to the fact that you will need an I/P address that resolves to your workstation in order to use IBM Debug Tool, there is no way that you can use the Sandbox or zServerOS for workshops that reflect the content in this unit. Your options for additional learning include: Return to the RDz Workbench Introduction unit – and carefully go over all the Debug option materials in the slides. Note that the workbench interface/perspective and > 95% of the functionality of Remote Debug is also contained in Local Debug. Along with this course you can watch the following Camtasias on RDz Debugging: 1. 2. RDz and Debugging  RDz and Remote Development (including Debugging)  Module 6 - Debugging COBOL programs

Topic Objectives After completing this unit, you should be able to: Describe the concept of source code debugging List the run-times that Debug Tool supports List the steps in preparing a program for debugging Debug a mainframe batch job Describe the run/step/animate options List PF-Keys associated with them Set/unset/inspect conditional and unconditional break-points Set "watch" break-points that halt execution when a value in a variable changes Show how to access the LPEX editor functionality during debugging (such as Perform Hierarchy) Be able to Jump to any given line, and run to a line Show how to change variable values dynamically during debug Show how to set different levels of variable display Monitor specific variables you are interested in Debug a CICS online transaction Discuss the Debug Option setup and configuration requirements for Online Debugging DTCN Profile/View DTCN Transaction Launch a CICS transaction that invokes Debug Tool Module 6 - Debugging COBOL programs

Debugging Overview Face facts: No one gets it right the first time. Not at the level of production business logic That's why IBM invented source-level application debuggers, so that you can: View program execution, line-by-line Verify the value of a variable – during program execution Stop and start program execution, and analyze results at the speed that our procedural understanding of the application's execution flow can handle The z/OS-based debugging engine is provided by the IBM Debug Tool for z/OS product. It runs on the z/OS.  "Perspectives" - Recall that a "Perspective" is a convenient grouping for a collection of views organized around a given role or task So far in this class, you've used the: z/OS Projects Perspective – to develop local COBOL applications Data Perspective – to develop local COBOL applications Debug Perspective – to do source-code (line-by-line) testing of your COBOL logic Module 6 - Debugging COBOL programs

Enter Source-Level Debuggers
Developing COBOL with IBM WebSphere Developer for zSeries Enter Source-Level Debuggers Specifically: IBM Debug Tool/PD Tools Family Green-screen (TSO-based) or RDz/Workstation-based interface to z/OS-based debugging engines Debug: Online (CICS, or IMS TM) Batch Multiple languages (COBOL, PL/I, HLASM, Java, etc.) Seamless debugging of mixed-language/cross-platform applications Interactive, source-level debugging in RDz with program running on z/OS Display, monitor and alter program variables Set standard types of breakpoints View data in Hex (EBCDIC) or string values Multiple configurable views Ability to make adjustments to the program while debugging Debug Tool product web-site: There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

Debug Tool - Application Environments
Developing COBOL with IBM WebSphere Developer for zSeries Debug Tool - Application Environments One debugging engine, with support for many environments: DB2 stored procedure UNIX systems services Batch CICS IMS/TM 3270 or GUI 3270 or GUI 3270 or GUI 3270 or GUI 3270 or GUI Debug Tool Debug Tool Debug Tool Debug Tool Debug Tool Debug tool provides a single debugging engine that supports many different environments. You can use the same debugger for your batch, CICS, and online IMS applications. It is the same debugging engine when you work with DB2 stored procedures and programs running with UNIX systems services on z/OS. As a result, you only have to learn to use a single debugger. You do not need a different debugger in each of your application environments. Batch Application CICS Application IMS Application DB2 Stored Procedure Posix Application Transaction Transaction Batch region CICS region IMS/TM region WLM region z/OS Module 6 - Debugging COBOL programs

RDz Interfacing with Debug Tool
Developing COBOL with IBM WebSphere Developer for zSeries RDz Interfacing with Debug Tool Debug Tool Engine Debug Tool Your Application Load Module TCP/IP z/OS Data Source There are also remote GUI interfaces to debug tool. The same debugging engine is used to control the application running on the mainframe, and it communicates with special software that is installed on your workstation. You can install RDz (Rational Developer for system Z) or RDDz (Rational Developer Debugger for system Z) to provide a GUI front end to debug tool. You may prefer to use one of these GUI debugging interfaces, since they are intuitive and easy to use. Debug tool can also interface with the GUI debugging front-ends available in a few other workstation software products including WDDz and WSED. The RDz remote debugger Client software that is installed with RDz on your workstation Communicates with the Debug Tool engine on the mainframe Note that Debug Tool must be installed on z/OS in order for you to do the labs in this unit Module 6 - Debugging COBOL programs

Steps for Batch Application Debug Session
Developing COBOL with IBM WebSphere Developer for zSeries Steps for Batch Application Debug Session Ensure that your compile proc has the necessary TEST parameter, and Compile/Link options and DD cards to create a debug-ready load module Discover workstation TCP/IP parameters: IP Address Listener port# Enter TCP/IP address of workstation in run JCL for Debug Tool DD statement, and Submit the JCL Debug the application There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

1. Compile JCL Requirements for Using Debug Tool
Developing COBOL with IBM WebSphere Developer for zSeries 1. Compile JCL Requirements for Using Debug Tool Use the TEST compiler option to prepare your executable COBOL program for use with the debugger. The TEST option is required for remote debugging. It produces symbol and statement information that enables the debugger to perform symbolic source-level debugging Enterprise COBOL 3.4: TEST(NONE,SYM,SEP) Enterprise COBOL V4.1 +: TEST(NOHOOK,SEP,EJPD) Include the DD card for your SYSDEBUG dataset in the COBOL Compile step In traditional compile JCL – this would be in the IGYCTRL step If you are not using the IBM/RDz compile PROCs for building your applications, be sure to override the compiler option and add TEST - as shown Transition statement: The following slide shows how to set the compiler options in the workbench. Omitting the TEST option is the same effect as specifying the NOTEST compiler option. Module 6 - Debugging COBOL programs

1a. Additional Compile JCL Requirements for Using Debug Tool for Assembler To debug Assembler programs, you will need additional datasets and steps: SYSADATA EQALANGX Step creates Debug symbolics See the Debug Tool v11 Users Guide – Chapter 6 Preparing an Assembler program – for more information on these datasets. Sample Assembler JCL is in the slide notes Transition statement: The following slide shows how to set the compiler options in the workbench. Omitting the TEST option is the same effect as specifying the NOTEST compiler option. Module 6 - Debugging COBOL programs

2. Discover TCP/IP address and RDz Port
Developing COBOL with IBM WebSphere Developer for zSeries 2. Discover TCP/IP address and RDz Port Open the Debug Perspective Click the small downward pointing triangle next to the debug-daemon icon Note the Port# Select: Get Workstation IP… Copy the IP address That shows this pull-down menu that displays the listening port. In this example it is port number 8001, but yours may be different. Just so you know, you can configure RDz so that it uses a different port if you prefer. Also due to security reasons, Port# 8003 is used frequently Note: Your RDz Port# will most likely be set once, and will change infrequently. However, depending on your installation's setup, your workstation's TCP/IP address could change - often See Notes Module 6 - Debugging COBOL programs

3. Paste in the TCP/IP Address and Submit the JCL
Developing COBOL with IBM WebSphere Developer for zSeries 3. Paste in the TCP/IP Address and Submit the JCL Configure your application to start Debug Tool by including a specific DD card in the run JCL – that includes your workstation's current Port# and TCP/IP address This is an example of JCL to run a batch job The CEEOPTS DD statement is the easiest way to start the Debug Tool for batch applications Code as shown //CEEOPTS DD * TEST(,,,TCPIP& %8001:) Next, go to your z/OS system. The next step is to configure your host application so that it triggers Debug Tool when it runs. This is an example of batch JCL that has been modified to start Debug Tool. Some people choose to start Debug Tool for certain batch applications by coding a CEEOPTS DD statement and specifying a TEST parameter. Notice that the workstation IP address and port number have been coded in the TEST parm. When this job is submitted and runs, Debug Tool will start and will connect to RDDz. There are a lot of different ways to start Debug Tool. This example shows only one method. If you would like to see other ways to start the debugger, review the tutorial sections that describe starting the debugger. Save your edits, and Submit the JCL Module 6 - Debugging COBOL programs

3a. Submit the JCL for Assembler Debugging
Developing COBOL with IBM WebSphere Developer for zSeries 3a. Submit the JCL for Assembler Debugging Configure your application to start Debug Tool by including a specific DD card in the run JCL – that includes your workstation's current Port# and TCP/IP address This is an example of JCL to run a batch job The EQANMDBG DD statement is the easiest way to start the Debug Tool for batch applications //EQANMDBG DD * PGM TEST(,,,TCPIP& %8003:) //DDS0001J JOB , // MSGCLASS=H,MSGLEVEL=(1,1),TIME=(,4),REGION=144M,COND=(16,LT) //* ADD A JOB CARD ABOVE THIS LINE //******************************************************************** //* RUN SAMPLE NON-LE ASSEMBLER PROGRAM ASAM //* CALLS ASSEMBLER SUBPROGRAM ASAM //* //******************************************************************** //* //* THE ORIGINAL EXEC STATEMENT IS COMMENTED: //*** ASAM1 EXEC PGM=ASAM1,PARM='123,ABC' //* THIS EXEC STATEMENT WITH AN EQANMDBG DD WILL START DEBUG TOOL //* FOR A NON-LE PROGRAM //ASAM1 EXEC PGM=EQANMDBG,PARM='123,ABC' //EQANMDBG DD * ASAM1,TEST(,,,TCPIP& %8003:) //* ASAM1,TEST(,,,MFI%TRMDT004:) //* ASAM1,TEST(,,,TCPIP& %8001:) //************** OTHER OPTIONAL DD'S FOR DEBUG TOOL ********* //** //INSPLOG DD SYSOUT=* //** //EQADEBUG DD DSN=&SYSUID..ADLAB.SYSDEBUG,DISP=SHR //** // DD DSN=&SYSUID..ADLAB.EQALANGX,DISP=SHR //** //INSPPREF DD DSN=&SYSUID..ADLAB.DTPREF,DISP=SHR //*********************************************************** //IDILANGX DD DSN=DDS0001.EQALANGX,DISP=SHR //STEPLIB DD DSN=DDS0001.TEST.LOAD,DISP=SHR //*** DD DISP=SHR,DSN=DEBUG.V9R1.SEQAMOD (UNCOMMENT IF NEEDED) //*** DD DISP=SHR,DSN=CEE.SCEERUN (UNCOMMENT IF NEEDED) //FILEIN DD *,DCB=(LRECL=80) INPUT RECORD ONE INPUT RECORD TWO INPUT RECORD THREE INPUT RECORD FOUR INPUT RECORD FIVE INPUT RECORD SIX INPUT RECORD SEVEN INPUT RECORD EIGHT XBEND <=== "ABEND" WILL CAUSE THE SAMPLE PROGRAM TO ABEND //FILEOUT DD SYSOUT=* //******************************************************************* //* SAMPLE FILES AND PARAMETERS FOR DEBUG TOOL AND FAULT ANALYZER: //* SAMPLE TEST PARMS TO START DEBUG TOOL: //* //* YOU CAN START DEBUG TOOL BY CODING A TEST PARM. EXAMPLES: //* CONNECT TO THE DT VTAM TERMINAL MANAGER INTERFACE: //* TEST(,,,VTAM%USERID:) //* CONNECT TO A VTAM TERMINAL IN BATCH: //* TEST(,,,MFI%TERMID:) //* CONNECT TO A TERMINAL, AND USE A COMMAND AND PREFERENCE FILE: //* TEST(,INSPIN,,MFI%TERMID:INSPPREF) //* CONNECT TO A REMOTE DEBUGGER, PORT 8001: //* TEST(,,,TCPIP& %8001:) //* SAMPLE OPTIONAL FILES FOR DEBUG TOOL //* PREFERENCES FILE: //* //INSPPREF DD DSN=&SYSUID..ADLAB.DTPREF,DISP=SHR //* COMMAND FILE: //* //INSPIN DD DSN=&SYSUID..ADLAB.DTCMD,DISP=SHR //* LOG FILE: //* //INSPLOG DD DSN=&SYSUID..ADLAB.DTLOG,DISP=SHR //* //INSPLOG DD DSN=SYSOUT=* //* EQADEBUG FILE (CONCAT. OF SYSDEBUG, LISTINGS, EQALANGX FILES): //* //EQADEBUG DD DSN=&SYSUID..ADLAB.SYSDEBUG,DISP=SHR //* // DD DSN=TEST.SYSDEBUG,DISP=SHR //* // DD DSN=QA.SYSDEBUG,DISP=SHR //* // DD DSN=PROD.SYSDEBUG,DISP=SHR //* SAMPLE OPTIONAL FILES FOR FAULT ANALYZER: //* //* IDIOPTS CAN BE USED TO SPECIFY FAULT ANALYZER PARAMETERS //IDIOPTS DD * INCLUDE,MAXMINIDUMPPAGES(1000) NODUP(NORMAL(0)) /* //* IDIOFF, IF PRESENT, WILL TURN OFF FAULT ANALYSIS FOR THE STEP //* //IDIOFF DD DUMMY //* IDILCOB IS A PDS CONCATENATION FOR COBOL COMPILER LISTINGS: //* //IDILCOB DD DSN=&SYSUID..ADLAB.LISTING,DISP=OLD //* IDILANGX IS A PDS CONCATENATION FOR LANGX FILES: //* //IDILANGX DD DSN=&SYSUID..ADLAB.EQALANGX,DISP=OLD //* IDISYSDB IS A PDS CONCATENATION FOR SYSDEBUG FILES: //* //IDISYSDB DD DSN=&SYSUID..ADLAB.SYSDEBUG,DISP=OLD //* IDITRACE CAN BE USED TO PRINT A TRACE OF THE LISTINGS SEARCH //IDITRACE DD SYSOUT=* Sample JCL In Slide Notes Module 6 - Debugging COBOL programs

Debug Tool - Prompts Debug Tool will interface with RDz and throw the Confirm Perspective Switch prompt Click Yes Additionally, if your mainframe source code is out sync with the Load Module you'll get an informational prompt. This typically means you need to check your compile listings for syntax errors that caused the link edit step not to execute because of condition codes Next, go to your z/OS system. The next step is to configure your host application so that it triggers Debug Tool when it runs. This is an example of batch JCL that has been modified to start Debug Tool. Some people choose to start Debug Tool for certain batch applications by coding a CEEOPTS DD statement and specifying a TEST parameter. Notice that the workstation IP address and port number have been coded in the TEST parm. When this job is submitted and runs, Debug Tool will start and will connect to RDDz. There are a lot of different ways to start Debug Tool. This example shows only one method. If you would like to see other ways to start the debugger, review the tutorial sections that describe starting the debugger. Module 6 - Debugging COBOL programs

4. Debug Tool Connects to RDz
Developing COBOL with IBM WebSphere Developer for zSeries 4. Debug Tool Connects to RDz Debug Perspective is launched in RDz Same debugging features as Local COBOL Debug (from previous course unit) Your source is copied down from z/OS to your RDz workstation Execution is on z/OS Assembler Note: You will need to use the Debug Console – and issue the command: LDD Programname Where: LDD is Load Debug file, and Programname is the name of your main module Regardless of the method you use to trigger Debug Tool on the host, when the application runs, Debug Tool starts and connects to RDz. When that happens, you will see information about the application displayed in the “Debug” window, and if available, you may see program source code displayed. You can get help at any time by clicking “Help” on the menu. See Slide Notes for Assembler Debugging Module 6 - Debugging COBOL programs

The Debug Perspective and Views
Developing COBOL with IBM WebSphere Developer for zSeries The Debug Perspective and Views Variables Breakpoints Monitor Views The Debug Icons That reset all of the views to their original, default positions. Take a look at the Debug view. It is in the upper left pane. It displays information about the current debugging session. Notice that it shows you the current program call chain, so you know where you are in the application. If you left-click a program name in the Debug window, you can see it’s source, and a right-click will display the program’s properties. Your code Program Outline View Module 6 - Debugging COBOL programs

Action Icons – Review Debug Listener (Should be green) Resume: Run the program to the next breakpoint or to the end Step Return: run until return from subprogram Terminate: End the program Step Over: run one statement, but step over a CALL Notice the icons in the action bar. You can click on these icons to make the program take certain actions such as run to the next breakpoint or run a single statement. The green triangle is resume. If you click on it, the program will run until it hits a breakpoint. If you do not have any breakpoints, or if the program does not reach any of your breakpoints as it runs, it will run all the way to the termination of the application. The red box is terminate. It forces the immediate termination of the application with a zero return code. If you terminate the application this way, no more statements run. The disconnect icon lets you disconnect Debug Tool from the application, but allow the application to continue normally. You might use this if you have seen what you needed to see in the debug session, and the program is running as expected, and you want to let it complete normally but do not need to watch it. The yellow down arrow is “step”, or “step into”. Step runs a single program statement. You can watch a program run statement by statement by clicking on the step icon several times in row. In many cases, if the current statement calls a sub-program, the step button will step directly into the subroutine or procedure. The step over icon allows you to step over a CALL statement or procedure call. Use this if you want to run a subroutine or procedure, but do not need to see the sub-program in the debugger. The step return icon can be used when you are already in a sub-program. Click on this, and the application will run until the next program return. Use it to quickly run to the end of a program or sub-program. Step: run one statement Disconnect: from the debug engine Animated Step Continuous source-level debugging without user interaction Module 6 - Debugging COBOL programs

Run Menu Shows same + additional debugging functionality as icons on toolbar However, not all Run menu functionality enabled for COBOL/PL1 Also shows hot-keys Your PC's function keys Context-sensitive: Options are grayed in current debug session if not applicable You can also select an action by selecting “run” from the menu. And remember that there are keyboard combinations that you can use to perform the same actions. Module 6 - Debugging COBOL programs

Statement Breakpoints – Review
Developing COBOL with IBM WebSphere Developer for zSeries Statement Breakpoints – Review A statement breakpoint will stop the program when it reaches a statement: It stops before the statement runs A breakpoint can optionally be made conditional A simple condition may be specified such as: VariableX > 999 …or… VariableY = 'Abc' A breakpoint can be based on a frequency: Stop the Nth time a statement runs You can set breakpoints that will trigger when the program gets to a specific statement. Statement breakpoints trigger before the statement runs, and the debugger pauses, showing the statement as the active statement. Optionally, you can make a statement breakpoint conditional, so that it only triggers at that statement if the condition is true. For example, a variable must have a certain value. Also, you can trigger a breakpoint based on frequency. That is an easy way to pause the program when a certain statement has run, say, 1000 times. Module 6 - Debugging COBOL programs

Set a Statement Breakpoint – Review
Developing COBOL with IBM WebSphere Developer for zSeries Set a Statement Breakpoint – Review One way to set a statement breakpoint is to double-click in the gray area to the left of the statement. dbl click Set a statement breakpoint by double-clicking in the gray area next to a statement Module 6 - Debugging COBOL programs

Set/Edit Conditional Statement Breakpoints
Developing COBOL with IBM WebSphere Developer for zSeries Set/Edit Conditional Statement Breakpoints Select the Breakpoint. Right-click and select: Edit Breakpoint… A breakpoint can trigger the Nth time the statement runs… You can specify optional breakpoint options. If you enter a number in the “from” field, that specifies how many times the statement has to run before the breakpoint triggers. For example, say that you want to read an input file until you get to record number Set a statement breakpoint on the READ statement in the program, with a “from” value of When you resume the program, it will be paused at the read statement just before it is ready to read the 500th record. You can also enter an expression in the “expression” field. You will see more about that in a minute. Click on the “finish” button. Action In the Action field you can specify a: “GO" command - continue execution to the next ABC (Abend, Breakpoint, or Completion) “JUMPTO" command - move the execution point to a specific line “RUNTO" command” - continue the execution to a specific line “STEP" command - walk through the program 1 or more lines … and breakpoints can be conditional. See Slide Notes on Action: Can set to different statement/line Or click Next > to specify conditional breakpoint logic Module 6 - Debugging COBOL programs

Watch Monitor Breakpoints
Developing COBOL with IBM WebSphere Developer for zSeries Can have breakpoints occur conditionally, when: The value in a field changes Some portion (# of bytes) of a field changes A simple condition tests true for the value in the field Steps: Select a variable Right-click, and select: Add Watch Breakpoint… Select Number of bytes to watch – or add a simple condition Specify Auto to test for all bytes You can specify optional breakpoint options. If you enter a number in the “from” field, that specifies how many times the statement has to run before the breakpoint triggers. For example, say that you want to read an input file until you get to record number Set a statement breakpoint on the READ statement in the program, with a “from” value of When you resume the program, it will be paused at the read statement just before it is ready to read the 500th record. You can also enter an expression in the “expression” field. You will see more about that in a minute. Click on the “finish” button. Module 6 - Debugging COBOL programs

Run to a Statement Breakpoint
Developing COBOL with IBM WebSphere Developer for zSeries Run to a Statement Breakpoint Resume click Notice that your breakpoints are shown in the breakpoints view. In this example, the program is about to run statement You know that because it is the highlighted statement. The “resume” button is clicked. If you are on a call statement and issue the STEP command, it will STEP INTO (default of the STEP command) the called routine and bring up the source for the called program. If you want to bypass the CALL statement all together you can reposition the execution pointer past the CALL statement by using the JUMPTO line-nnn command. If you just want the called program to execute w/o having the source for the called routine comes up, you can issue the STEP OVER command which will execute the called routine and just move you to the next statement in the current program. Or…to Run (Resume) without stopping try using the STEP RETURN command A breakpoint icon is shown… and the breakpoint is also shown in the Breakpoints view. See Slide Notes Module 6 - Debugging COBOL programs

Breakpoint Options (from the Breakpoints View)
Developing COBOL with IBM WebSphere Developer for zSeries Breakpoint Options (from the Breakpoints View) The program ran to the breakpoint And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. You can remove the breakpoint by double clicking again here… … or by deleting it from the Breakpoints view Module 6 - Debugging COBOL programs

Variables View During Remote Debug – Additional Options
Developing COBOL with IBM WebSphere Developer for zSeries Variables View During Remote Debug – Additional Options Many options for working with variables  Add to Monitor – for permanent viewing  Monitor internal memory values  Show value in hex – (EBCDIC internal) or string value representation  Copy variable and value to Notepad  Find specific variable in filtered Locals  Show specific variables in the view And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. With large COBOL programs can "filter" and display only certain categories of variables Module 6 - Debugging COBOL programs

Variables View – EBCDIC (Hex) Data Representation
Developing COBOL with IBM WebSphere Developer for zSeries Variables View – EBCDIC (Hex) Data Representation Value – in string or numeric display (depends on datatype) display And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Value – in EBCDIC internal display  very useful for debugging data exceptions Module 6 - Debugging COBOL programs

Monitors View – Options
Developing COBOL with IBM WebSphere Developer for zSeries Monitors View – Options Monitored variable value – in EBCDIC internal display  very useful for debugging data exceptions Add datatype prefix to variable data-name displayed – still retail variable value) And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Module 6 - Debugging COBOL programs

Monitors – Detach the Eclipse View
Developing COBOL with IBM WebSphere Developer for zSeries Monitors – Detach the Eclipse View Very useful Best Practice… And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Can view any # of variable values during debug, animated debug or Resume to breakpoints Module 6 - Debugging COBOL programs

Monitor Memory Monitor Memory The memory content can be shown (or “rendered”) in several different formats: Raw HEX, EDBCDIC or ASCII Tree structure using customized XML mappings. 1) The Memory view shows the contents of storage at a particular address. This memory content can be shown (or “rendered”) in several different formats, such as raw HEX, EDBCDIC or ASCII, or even as a tree structure using customized XML mappings. 2) The separate Memory and Memory Rendering views in RDz V6 have been consolidated into a single Memory view in V7. Rendering tabs can be stacked, or placed side-by-side in a split-pane mode. If placed side-by-side, cursor movements in one rendering can be mirrored in the other rendering. Module 6 - Debugging COBOL programs

The Debug Console View Rational Developer for System z messages You can enter a subset of commands from the Debug Tool 3270 interface, a list of Debug Tool commands that are valid for use in RDz can be found in the Appendix of the Debug Tool Reference and Messages Guide. The Debug Console view shows RDz messages and lets you enter some Debug Tool commands The debug console view shows messages that are produced by RDDz, and lets you enter certain Debug Tool commands. You can enter a subset of commands that are used in the 3270 Debug Tool interface. For example, if you enter “set automonitor on”, or it’s abbreviation, that will turn on the automonitor. In most cases, the debug console view is used infrequently to turn on certain settings or load source information. That is the end of part one of using the RDDz remote debugging interface. Place your cursor in the Command area and press Ctrl+Spacebar – to see a list of available commands Module 6 - Debugging COBOL programs

Debug Option – Jump to / Run To Jump to Location - skip over sections of code to avoid executing certain statements or move to a position where certain statements can be executed again. Useful: To avoid called programs or I/OS to a not available dataset Or to iteratively execute some statements of interest Run to Location - executes all statements between the current location and the run-to location. Module 6 - Debugging COBOL programs

How to return from anywhere in your program to the Current Instruction
To get back to the Current Instruction Pointer (the "next sequential instruction") – if you've navigated away within the source: Click the small blue rectangle in the right-hand margin of your source code

Outline View – Code Sync Options
Developing COBOL with IBM WebSphere Developer for zSeries Outline View – Code Sync Options While debugging through PROCEDURE DIVISION Outline view synchronizes with code in paragraphs and sections But if you scroll in the code while stepping, the Outline View syncs with your browsing activity And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Module 6 - Debugging COBOL programs

Debug Console View – Other Icon-Function Options
Developing COBOL with IBM WebSphere Developer for zSeries Debug Console View – Other Icon-Function Options There are a number of useful Debug Console commands that work with RDz SET INTERCEPT ON - allows you to see your program's DISPLAY statement output that ordinarily goes to //SYSOUT And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Hint: Ctrl+Spacebar with your cursor in the Command area lists the Console commands that work with RDz Module 6 - Debugging COBOL programs

Debug Console Commands – Tracing Through Statement Execution
Developing COBOL with IBM WebSphere Developer for zSeries Debug Console Commands – Tracing Through Statement Execution This is another very popular command: SET AUTOMONITOR ON LOG It forces Debug Tool to track each statement as it's executed and write it to the Debug Console Using this technique you can copy and paste your program's dynamic execution and trace forward and backward through any portion of your code You can also copy all of the statements to hard-copy : Right-click Select Export History Specify a file – preferably an RTF or MS-Word doc, as formatting will be retained And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Module 6 - Debugging COBOL programs

Outline View – Display Statements Options
Developing COBOL with IBM WebSphere Developer for zSeries Outline View – Display Statements Options For large programs, several additional Outline view features are available as toggled icons: Click to Toggle function on Click again to Toggle function off Sort all variables And the program ran until it reached the next breakpoint. If you want to remove the breakpoint, you could double-click on the breakpoint icon in the gray area to the left of the statement. Or you could also delete it from the breakpoints view. Module 6 - Debugging COBOL programs

Handling program abends
Developing COBOL with IBM WebSphere Developer for zSeries Handling program abends Debug Tool can receive control back from the system after an abend occurs The program will be stopped at the abending statement You can: Allow the application to abend and terminate Capture abend info with a product such as Fault Analyzer Terminate the application and prevent further processing Or continue running the program Usage note: The LE TRAP(ON) option must be active Module 6 - Debugging COBOL programs

Terminating the application
Developing COBOL with IBM WebSphere Developer for zSeries Terminating the application There are several options for terminating your application: Remain in the debugger, and RESUME until the program runs to completion The program will terminate normally or with an abend The return code is controlled by the program Disconnect the debugger, and allow the program to run to completion Module 6 - Debugging COBOL programs

Termination action buttons
Developing COBOL with IBM WebSphere Developer for zSeries Termination action buttons You can immediately terminate the application using action buttons Disconnect: Disconnect Debug Tool from the application. The program continues to run from the current location without the debugger. And subsequent batch job steps can finish as well. Terminate: Immediate termination of the application. No more program statements run. RC=0 is returned to the environment. Module 6 - Debugging COBOL programs

Force an immediate termination with abend
Developing COBOL with IBM WebSphere Developer for zSeries Force an immediate termination with abend 1 Right click in the Debug view rightclick Terminate and abend 3 Options click click 2 Module 6 - Debugging COBOL programs

Restart Your Debugging Session
Developing COBOL with IBM WebSphere Developer for zSeries Restart Your Debugging Session For batch debugging If your submitted JCL is still in the code (Content) area No need to return to the z/OS Projects perspective Right-click Select: Submit Module 6 - Debugging COBOL programs

Summary Having completed this unit, you should now be able to: Describe where the debug engines are located Show how to set the workbench preferences for running and debugging Show how to invoke the debugger for local programs Describe the views of the Debug perspective Demonstrate how to set breakpoints in COBOL code Explain how to set up the COBOL compile options for remote debugging Show how to debug a remote batch COBOL program Module 6 - Debugging COBOL programs

The RDz Workbench UNIT Topics: Debugging z/OS COBOL Batch Applications
Debugging z/OS COBOL Online Applications Appendix

Topic Objectives After completing this unit, you should be able to: Using the Problem Determination Tools, Debug Option and RDz: Debug a mainframe online transaction Describe the online transaction features for configuring your 3270 sessions with Debug Option Debug a CICS 3270 Application Module 6 - Debugging COBOL programs

Online Debugging Overview
Developing COBOL with IBM WebSphere Developer for zSeries Online Debugging Overview Guess what? No one gets it right the first time coding online programs either  Lucky for you: Debug tool handles: CICS 3270 online transactions IMS TM online transactions Without any different debugging techniques The only difference from batch is the debug setup procedure for the online environment The z/OS-based debugging engine is provided by the IBM Debug Tool for z/OS product. It runs on the z/OS.  "Perspectives" - Recall that a "Perspective" is a convenient grouping for a collection of views organized around a given role or task So far in this class, you've used the: z/OS Projects Perspective – to develop local COBOL applications Data Perspective – to develop local COBOL applications Debug Perspective – to do source-code (line-by-line) testing of your COBOL logic Module 6 - Debugging COBOL programs

Steps for Online (CICS) Application Debug Session
Developing COBOL with IBM WebSphere Developer for zSeries Steps for Online (CICS) Application Debug Session Ensure that your compile proc has the necessary TEST parameter, and Compile/Link to create load module – and that your CICS application is setup for Debug Option testing Discover workstation TCP/IP parameters: IP Address Listener port# Access and login to your CICS region – Green Screen Use the DTCN view, or execute the DTCN transaction and specify: Terminal ID Transaction code and programs – to put under Debug control User-ID TCP/IP parameters: Port# Save the DTCN transaction specification Debug your CICS application There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

1. Compile JCL Requirements for Using Debug Tool
Developing COBOL with IBM WebSphere Developer for zSeries 1. Compile JCL Requirements for Using Debug Tool Use the TEST compiler option to prepare your executable COBOL program for use with the debugger. The TEST option is required for remote debugging. It produces symbol and statement information that enables the debugger to perform symbolic source-level debugging Enterprise COBOL 3.4: TEST(NONE,SYM,SEP) Enterprise COBOL V4.1 +: TEST(NOHOOK,SEP,EJPD) Include the DD card for your SYSDEBUG dataset in the COBOL Compile step In traditional compile JCL – this would be in the IGYCTRL step If you are not using the IBM/RDz compile PROCs for building your applications, be sure to override the compiler option and add TEST - as shown Transition statement: The following slide shows how to set the compiler options in the workbench. Omitting the TEST option is the same effect as specifying the NOTEST compiler option. Module 6 - Debugging COBOL programs

2. Discover TCP/IP address and RDz Port - Review
Developing COBOL with IBM WebSphere Developer for zSeries 2. Discover TCP/IP address and RDz Port - Review Open the Debug Perspective Click the small downward pointing triangle next to the debug-daemon icon Note the Port# Select: Get Workstation IP… Copy the IP address Either paste the IP address into Notepad, or write it down That shows this pull-down menu that displays the listening port. In this example it is port number 8000, but yours may be different. Just so you know, you can configure RDDz so that it uses a different port if you prefer. Next, click on “Get workstation IP”. Note: Your RDz Port# will most likely be set once, and will change infrequently. However, depending on your installation's setup, your workstation's TCP/IP address could change - often Module 6 - Debugging COBOL programs

3. Setup the DTCN Parameters Using the DTCN View
If you are using RDz v7.6.1 or higher, you can utilize an RDz view to setup your DTCN CICS Debug properties. Steps: From Window > Show View > Other type: DTCN and select DTCN Profiles Right-click inside the new, empty view and select: Create From the DTCN profiles window: Enter your User ID Click DTCN Preferences From DTCN preferences specify: Host Name/IP Address CICS DTCN transaction port CICS login credentials: User ID Password Other fields as shown  Click Test Connection Click OK to check your work

Setup the DTCN Parameters Using the DTCN View – continued
From DTCN profiles click Next > From DTCN pattern matching specify : Terminal ID: * Transaction ID (Trancode)  Click Add, and specify the Compile Units (Load Module names) Click Next > From DTCN TEST run-time specify: Fields as shown  Session Address (your workstation I/P address) Port (your listener Debug Tool listener port) Other fields – as shown  Click Finish DTCN Profiles will be populated with entries for all users connecting into that CICS region

Using the DTCN View Once you have setup the DTCN View, you can: Activate the profile This modifies the CICS System Tables dynamically, through the Debug Tool facilities – and allows you to debug CICS transactions Other options include: Edit the profile – and change your I/P address After you reboot your machine Delete the profile Create a new profile Refresh the display of DTCN entries in the region Note: In order to debug CICS programs you will have to launch a 3270 emulation session (next slides) to kick off the transaction

3. Login to your CICS Region
Developing COBOL with IBM WebSphere Developer for zSeries 3. Login to your CICS Region From Remote Systems Explorer: Right-click Select: Host Connection Emulator Select your CICS application Enter your Userid and Password and sign in There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

3. Setup the Debug Option Parameters using DTCN Transaction – 1 of 2
Developing COBOL with IBM WebSphere Developer for zSeries 3. Setup the Debug Option Parameters using DTCN Transaction – 1 of 2 If you did NOT use the DTCN view to enter your DTCN properties you can do so using a CICS Transaction (green screen) From CICS (after signing in): Clear the screen, Enter: DTCN – and press  Enter From the DTCN screen Press F10 – this will fill in the Terminal Id for your workstation Note that you can also type an asterisk: * …as the Terminal Id There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products.  Note: You would only use the DTCN transaction to specify your Debug Option properties if you could not use the DTCN view (prior slides) Module 6 - Debugging COBOL programs

3. Setup the Debug Option Parameters using DTCN Transaction – 2 of 2
Developing COBOL with IBM WebSphere Developer for zSeries 3. Setup the Debug Option Parameters using DTCN Transaction – 2 of 2 DTCN transaction data entry screen Enter the Tran-code Transaction ID Enter up to eight specific Program Id(s) you wish to debug through …or… Enter wildcard text for the Program Id(s) Ex. CD* Enter your User-ID Session Type: TCP Port Number: from your Debugger look-up Display ID: Your TCP/IP address, from your Debugger look-up (note that you can not paste into this 3270, screen) Press F4 to save your debug profile Press F3 to clear the screen There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

4. Start Debugging From the CICS region Enter the Tran-code Press  Enter Click: Yes at the Confirm Perspective Switch There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

4. Start Debugging Debug as previously learned in the batch/remote and Local debug units. There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

What Happens for Calls and Screen-IO? – 1 of 2
Developing COBOL with IBM WebSphere Developer for zSeries What Happens for Calls and Screen-IO? – 1 of 2 You will be prompted, and presented with debug-run-time options There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

What Happens for Calls and Screen-IO? – 2 of 2
Developing COBOL with IBM WebSphere Developer for zSeries What Happens for Calls and Screen-IO? – 2 of 2 If your current transaction ends, and a BMS or 3270 screen is sent: You will be notified (prompted) by the debug engine If a screen is sent, the 3270 will display in the content area There is also IBM Rational Developer Debugger for System z Version 7.0 which is an affordably priced subset of IBM Rational Developer for System z functions that is designed to provide a workstation-based graphical interface to IBM Debug Tool and IBM Debug Tool Utilities and Advanced Functions. This product is specifically designed for developers who do not require the full-function Rational Developer for System z product. The functions listed on this page are available in both the Rational Developer for System z and Rational Developer Debugger for System z products. Module 6 - Debugging COBOL programs

What About PF-Keys and Other Data Entry?
You can resize the screen portion of the debugger And use the PF-Key emulation options in the Host Connection

Same Debug Option Functionality!
All of the debugging features and functions are available when debugging online CICS or IMS TM applications.

Topic Objectives After having completed this unit, you now should be able to: Using the Problem Determination Tools, Debug Option and RDz: Debug a mainframe online transaction Describe the online transaction features for configuring your 3270 sessions with Debug Option Debug a CICS 3270 Application Module 6 - Debugging COBOL programs

Requires RDz v8.0.3 (or later) and Debug Tool v11.1 (or later)
Appendices Code Coverage Requires RDz v8.0.3 (or later) and Debug Tool v11.1 (or later) Local COBOL Workshop that does File I/O Additional (back-up) slides

Code Coverage – 1 of 4 Extension to Debug Tool: Tracks tested lines of code Improves application quality Focuses testing resource usage Reports on tested code and trends Supports: Batch, CICS and IMS TM Subset of Debug Tool Code Coverage (green-screen) Does not show how many times each line has been executed and a few other metrics ** Requires Debug Tool v11.1 – and you will need a specific Debug Tool PTF: PM44285 Module 6 - Debugging COBOL programs

Code Coverage – 2 of 4 Process: Compile/Link with standard Debug Tool JCL parms (TEST,SYM,SEP…etc.) Submit "GO" step – passing in a PARM with: Your I/P address and port# ENVAR("EQA_STARTUP_KEY=CC") Make sure that the Debug tool runtime library is in STEPLIB or JOBLIB <HLQ>…SEQAMOD Run your debug session. Instead of dropping into interactive Debug, your program will run to EOJ (or ABEND) After the job finishes a Code Coverage report opens in the editor (this takes a few seconds to build) Double-click a program to view the detailed lines  Get your I/P Address Plug it into the JCL From CTFMVS08: USER170.TEST.JCL(SAMJON2) Module 6 - Debugging COBOL programs

Code Coverage – 3 of 4 Specifying the ENVAR parameter Batch: PARM card //CEEOPTS DD card Online DTCN Profile DTCN Transaction Get your I/P Address Plug it into the JCL From CTFMVS08: USER170.TEST.JCL(SAMJON2) Module 6 - Debugging COBOL programs

Code Coverage – 4 of 4 RDz Version 8.5 offers:
Choice of Function or Line level coverage Threshold settings - i.e. line level must be >80% covered to be considered successful Code Coverage launch view enhancements Success indicator - based on thresholds Actions appear in popup menu when selecting results - improved usability 72

Local COBOL Project Debugging
Important notes before you begin: As of RDz version 7.6 and later - compiling and debugging workstation-based (Local) COBOL or PL/I applications was "Deprecated" – meaning that no future development or enhancements are planned for this functionality For off-host, or offloaded application testing IBM recommends RD&T: To that end – compiling and debugging Local COBOL or PL/I applications only works if you're using the Windows XP and Vista. Local Debug is not supported on Windows 7 or Linux – at any RDz release Also – when you install RDz, Windows compile is not checked on (by default) – so you must check it explicitly. Note that you can return to Installation Manager and "modify" your install at any time.

Steps in Debugging Local Workstation Projects
Developing COBOL with IBM WebSphere Developer for zSeries Steps in Debugging Local Workstation Projects If you're looking for more extended code to practice your new RDz edit/debug skills with – the workshop slides in this appendix will allow you to import and setup a small 5-program system for debugging, and use the more sophisticated Debugging techniques, suitable for production-level work: Entry breakpoints, Watch monitors, You will read and write files, do an inline sort, etc. Recall from a previous course unit, that in order to Debug you will need the following: A project – that compiles to an EXE (executable) One or more COBOL programs to debug in the project Data files A Debug Configuration We will provide you with explicit steps to accomplish that. Sequential Input/Output Files Debug Configuration RDz Debug Perspective COBOL.exe + Called modules Output Reports The module and data flow is shown on the next slide Module 6 - Debugging COBOL programs

Module and Data Flow Diagram (From Rational Asset Analyzer)
This is the batch job diagram, that was produced by Rational Asset Analyzer from the original program and JCL code In order to make this report view-able on one slide we have annotated the diagram HOSPEDIT HOSPSRCH HOSPDRVR QSAM Data Files HOSPSORT HOSPCALC File Descriptions

Debugging Local Workstation Projects – 1 of 5
1. Download the zip file that's on: - named: hospproject.zip 2. Import this project, and configure it for debug - as follows: From the File menu, select Import Select: Other > Project Interchange ( click Next > )  From zip file: Browse to the downloaded zip file and select it. Check the box, and click Finish

Modify the FILE-CONTROL entries. In four of these programs there are ASSIGN statements that point to my Project's Workspace. You will need to modify the bold text shown here, to point to your own project Workspace... Drive:\folder\

Make sure that the Properties are configured for your Workspace Example - SYSLIB must point to your workspace (not mine) for COPY statements (and there are COPY statements in all of the programs):

Delete the BuildOutput folder, then Rebuild the HospProject Project By deleting the folder, and watching the Rebuild create it, you ensure the proper executables G. Create a new Debug Configuration Again - point to the correct Workspace - and make HospDrvr.exe the Program entry point

Step through the code – same skills/techniques as all the other Debug examples:

Additional (back-up) slides
Appendices Additional (back-up) slides

Breakpoints - Review Temporary markers you place in your program that tell the debugger to suspend executing your program at a given point. Setting a breakpoint in a statement causes the execution to stop Source can then be stepped through and variables inspected Breakpoints are set until they are explicitly removed Breakpoints can be Removed, temporarily Disabled, Exported, Imported, etc. Module 6 - Debugging COBOL programs

Debug View: Stepping Through Code "Run" to next breakpoint "Terminate" execution “Animated Step Into” - the debugger issues a step into action repeatedly. You can control the delay between each step by selecting the Animated Step Into icon down-arrow. "Step into" next statement (use for called programs) "Step over" next statement Run contained statements but don't stop on them "Run to return" to next higher level statement in program structure (return from a called program) Debug view Once execution has been suspended at a breakpoint, the source for the current stack frame can be executed line-by-line using the debugger’s navigation buttons Step debug This command executes the currently-selected line or statement and suspends at the next line encountered for which debug information is available. This could be in the current function, in the called function, or in a function called within the called function. Step Debug is currently only available when debugging Compiled Language Applications “Step filters” - to filter out types that you do not wish to see and or step through while debugging. (use for local debugging when assembler code is showing) Module 6 - Debugging COBOL programs

Variables View Variables view View current record contents Update record/structure item contents Double click on item name or right-click and select Change Variable Value Mouse (hover-over variable) also shows the contents Module 6 - Debugging COBOL programs

Monitor Variable Contents Monitors view View the contents of a Variable or Expression Variable/Expressions that you have selected and want to monitor at all times. Module 6 - Debugging COBOL programs

RDz Workbench – Debugging z/OS COBOL Applications

Similar presentations

Presentation on theme: "RDz Workbench – Debugging z/OS COBOL Applications"— Presentation transcript:

Similar presentations

About project

Feedback

Войти

Auth with social network:

RDz Workbench – Debugging z/OS COBOL Applications

Similar presentations

Presentation on theme: "RDz Workbench – Debugging z/OS COBOL Applications"— Presentation transcript:

Similar presentations

About project

Feedback