action.skip

Debugger Commands

Debugger Commands include:

  • break
  • backtrace (bt)
  • continue
  • contreturn
  • detach
  • delete
  • file
  • frame
  • info
    • info break
    • info line
    • info locals
    • info profiling
    • info region
    • info regions
    • info sources
    • info target
    • info var
  • kill
  • list
  • next
  • print
  • printh
  • quit (exit)
  • replace
  • run
  • set
    • set machine
    • set maxdata
    • set profiling
    • set prompt
    • set readline
    • set region
    • set sources
    • set term
    • set trace
    • set var
    • set varh
  • step
  • stop
  • thread
  • tty
  • up
  • version
  • whatis

break [-t]

break causes a breakpoint to be set in the location that is indicated.

Where:

  • -t indicates the breakpoint is temporary. Temporary breakpoints are erased after they have been reached the first time.
  • -v indicates the breakpoint is a Value Change breakpoint. Value Change breakpoints stops a program when the indicated variable's value changes.
  • <location> indicates a Flow of Control breakpoint. Flow of Control breakpoints stops a program when its flow of control (i.e. current statement) reaches the point indicated by location. (See below for more details.)

break [-t] <location>

<location> describes a location within the program where execution should stop (or break) when the current statement reaches it. The format of <location> is:

{`label` | [`module`]![{`label`|`line-nr`}]}

Where:

Parameter Description
module Sets a breakpoint in a module, as identified by program-id. If not present, the current module is assumed.
label Sets a breakpoint at a paragraph name.
line-nr Sets a breakpoint at a line number.

module, label, and line-nr can be combined, with a ! notation.

break [-t] label

break [-t] label sets a breakpoint at a paragraph name.

Example: 

       (cobcdb)
       break -t para-1
       Breakpoint 1 in para-1 at C:/COBOL/COBOLIT/samples/hello.cbl
       (cobcdb)

break [-t] module!label

break [-t] module!label sets a breakpoint at a paragraph name (label) in a module. module is identified by the source file name. If no module name is specified, then the current module is used. Since module may not be loaded yet, no validation of module!label is made.

Example: 

       (cobcdb)
       break -t C:/COBOL/COBOLIT/samples/hello.cbl!para-1
       Breakpoint 2 in para-1 at C:/COBOL/COBOLIT/samples/hello.cbl
       (cobcdb)

break [-t] module!line-nr

break [-t] module!line-nr sets a breakpoint at a line number in a module. module is identified by source file name. If no module name is specified, then the current module is used. Since module may not be loaded yet, no validation of module!line-nr is made.

Example: 

       (cobcdb)
       break -t C:/COBOL/COBOLIT/samples/hello.cbl!22
       Breakpoint 3 at C:/COBOL/COBOLIT/samples/hello.cbl!22
       (cobcdb)

break [-t] module!0

break [-t] module!0 sets a breakpoint at the entry-point to module. module is identified by source file name. If no module name is specified, then the current module is used.

Example: 

       break -t c:/COBOL/COBOLit/samples/subpgm.cbl!0
       Breakpoint 1 at c:/COBOL/COBOLit/samples/subpgm.cbl ! 0
       (cobcdb)

Or

       break -t subpgm.cbl!0
       Breakpoint 1 at subpgm.cbl ! 0
       (cobcdb)

break [-t] -v <variable-name>

  • variable-name is the name of a variable within the program whose value is to be monitored. Program execution will break when a statement changes the value of this variable.

The format of <variable-name> is:

   [module.]field-name

bt (also backtrace)

bt causes a CALL/PERFORM stack trace to be generated.

The format for the stack trace display is:
#<frame-number><module>() at <source-location>

Example: 

       bt
       #0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!21
       #1 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!16
       (cobcdb)

Frame-number 0 is the current program position.

continue

continue causes execution of program to be continued until the next breakpoint is encountered, or until the end of the program. An event-continue command is issued. As seen in the example below, this is interrupted when an event-breakpoint-hit event takes place.

Example: 

       break -t para-1
       Breakpoint 1 in para-1 at C:/COBOL/COBOLIT/samples/hello.cbl
       (cobcdb)
       continue
       -event-continue
       -event-breakpoint-hit (cobcdb)#0 hello () at 
       C:/COBOL/COBOLIT/samples/hello.cbl!22
       (cobcdb)

Example: 

       break -t C:/COBOL/COBOLIT/samples/hello.cbl!22
       Breakpoint 1 at C:/COBOL/COBOLIT/samples/hello.cbl ! 22
       (cobcdb)
       continue
       -event-continue
       -event-breakpoint-hit (cobcdb)#0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!22

contreturn

contreturn causes execution to continue to the next PERFORM return, or break on the first breakpoint reached, which ever comes first. An event-contreturn command is issued. This is interrupted when an –event-end-stepping-range event takes place.

Example: 

       contreturn
       -event-contreturn
       (cobcdb)-event-end-stepping-range #0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!17

detach

detach causes the debugger to close its connection to the running COBOL program and allows the program to run to completion.

delete <x>

delete <x> causes breakpoint number x to be deleted.

Example: 

       (cobcdb)
       delete 3
       ^done
       (cobcdb)

exit

exit is available only when the debugger is started without a program name option and before a file command is executed. It is equivalent to the quit command and will terminate the debugger.

file <program-name> [<command-line-arguments>]

file causes the debugger to load the indicated program-name and prepare for execution of it. This is used when cobcbg is started without any arguments. When started this way, the debugger will start and immediately read a command from standard input. file should be used as the first command to the debugger when it is in this state and the program to run will be loaded and the next statement to be executed will be the entry point to the program.

The options to file are:

  • <program-name> is the name of the shared object file created by the COBOL-IT Compiler (.dll, .so).
  • <command-line-arguments> are the command line arguments that are to be passed to the COBOL program via ACCESS from COMMAND-LINE statement. Any quotes in <command-line-arguments> are removed and multiple spaces will be compressed to one space.

Example:

       C:\dev\cobolit\CIT4.12>cobcdb
       file c:\Example\example.dll "1234     5678"
       CreateProcess "cobcrun -d c:\Example\example.dll 1234 5678 ".
       command:20748
       (cobcdb)
       event:20748
       -event-end-stepping-range .0000008>        MAIN SECTION.
       #0 EXAMPLE () at C:/dev/Defects/Example/example.cob!8
       list *
       .0000001.        IDENTIFICATION DIVISION.
       .0000002.        PROGRAM-ID. EXAMPLE.
       .0000003.        ENVIRONMENT DIVISION.
       .0000004.        DATA DIVISION.
       .0000005.        WORKING-STORAGE SECTION.
       .0000006.        01 PARAMETERS                   PIC X(80).
       .0000007.        PROCEDURE DIVISION.
       .0000008>        MAIN SECTION.
       .0000009.            ACCEPT PARAMETERS FROM COMMAND-LINE.
       .0000010.            DISPLAY PARAMETERS.
       .0000011.        END-MAIN.
       .0000012.            STOP RUN.
       (cobcdb)
       step
       -event-step
       (cobcdb)
       -event-end-stepping-range .0000009>            ACCEPT PARAMETERS FROM COMMAND-LINE.
       #0 EXAMPLE () at C:/Example/example.cob!9
       step
       -event-step
       (cobcdb)
       -event-end-stepping-range .0000010>            DISPLAY PARAMETERS.
       #0 EXAMPLE () at C:/dev/Defects/Example/example.cob!10
       step
       -event-step
       (cobcdb)
       -event-end-stepping-range .0000011>        END-MAIN.
       #0 EXAMPLE () at C:/Example/example.cob!11
       step
       -event-step
       -event-end-stepping-range (cobcdb)#0 EXAMPLE () at C:/dev/Example/example.cob!12
       .0000012>            STOP RUN.
       step
       -event-program-exited -event-step
       (cobcdb)#0 EXAMPLE () at C:/Example/example.cob!12

       .0000012>            STOP RUN.

frame <frame-number>

frame <frame-number> prints the source location for the designated frame number. The frame numbers of an application run session are the points at which the application has branched either due to a PERFORM <paragraph> statement or a CALL <subprogram> statement.

Example: 

       (cobcdb)
       frame 0
       #0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!25
       (cobcdb)
       frame 1
       #1 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!17
       (cobcdb)

info <info-parameter>

info causes information to be displayed about the <info-parameter> that is indicated. The info command requires an <info-parameter>.

Info parameters for the info command are:

Parameter Description
break Displays a list of breakpoints.
line Display the line number of a specified label.
locals Displays a dump of the current variables in memory.
region Display a dump of the current region in memory.
regions Displays a dump of all the regions in memory.
sources Displays a list of source files corresponding to loaded modules.
target Displays the Process ID of the runtime session.

info break

info break displays a dump of the current break points.

info line <label>

info line displays the line number of the specified label.

Example: 

       (cobcdb)
       info line MAINLINE-EXIT
       Line 80 of C:\example.cob label is MAINLINE-EXIT

info locals

info locals displays a dump of the values of the fields in the modules currently loaded in memory.

Example: 

       (cobcdb)
       info locals
       @hello.WORKING-STORAGE
       @hello.WORKING-STORAGE.RETURN-CODE = [10]"+000000000"
       @hello.WORKING-STORAGE.TALLY = [10]"+000000000"
       @hello.WORKING-STORAGE.SORT-RETURN = [10]"+000000000"
       @hello.WORKING-STORAGE.NUMBER-OF-CALL-PARAMETERS = [10]"+000000000"
       @hello.WORKING-STORAGE.message-line = [11]" "
       @hello.WORKING-STORAGE.ws-dummy = [1]" "
       @hello.WORKING-STORAGE.ctr = [6]"000000"
       @hello.WORKING-STORAGE.COB-CRT-STATUS = [4]"0000"
       (cobcdb)

info is returned in a structured tree using SECTION as a header in the form:
<variable name> = [<size>]"<string>"

  • <variable name> is the full qualified variable name.
  • <size> is the number of characters in the string.
  • <string> is the data in human readable form. Strings may contain null characters.

info profiling

info profiling causes a profiling dump to be produced, dumping profiling information at the current point in the program. Profiling information is displayed, and then dumped in the .xls file format.

Example: 

       (cobcdb)
       info profiling

info region

info region causes information about the current region to be dumped.

Example:

       info region
       R0 EXAMPLE () at C:/example.cob!83

info regions

info regions causes information about all the currently loaded regions to be dumped.

Example:

       (cobcdb)
       info regions
       R0 EXAMPLE () at C:/example.cob!83

info sources

info sources displays source files associated with objects loaded in memory.

Example: 

       (cobcdb)
       info sources
       Source files
       C:/COBOL/COBOLIT/samples/hello.cbl
       (cobcdb)

info target

info target displays the pid of the currently running process.

Example: 

       (cobcdb)
       info target
       Child PID 19012
       (cobcdb)

info var <variable-name>

info var dumps information about a specified variable name.

Example:

       run abcd
       (cobcdb)
       -event-breakpoint-hit .0000009>            ACCEPT PARAMETERS FROM COMMAND-LINE.
       #0 EXAMPLE () at C:/Example/example.cob!9
       step
       -event-step
       (cobcdb)
       -event-end-stepping-range .0000010>            DISPLAY PARAMETERS.
       #0 EXAMPLE () at C:/Example/example.cob!10
       info var PARAMETERS
       @EXAMPLE.WORKING-STORAGE.PARAMETERS = [80]"abcd                                                                            "

kill

kill terminates the current process.

Example: 

       (cobcdb)
       kill
       -event-program-exited (cobcdb)#0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!10

list [[+ | -]<start> | * [[+]<stop> | * ]]

The list debugger command requires that the source file be accessible. The list debugger command allows you to expand the source you can see inside the console debugger as you execute your debugger commands:

       (cobcdb)
       s
       -event-step
       (cobcdb)
       -event-end-stepping-range
       #0 CUSTOMER0 () at /opt/cobol-it-64/samples/customer0.cbl!99
       .0000099>     CALL "C$PID" USING PID.
       list
       .0000094.
       .0000095.     ******************************************************************
       .0000096.      PROCEDURE DIVISION.
       .0000097.
       .0000098.     Main Section.
       .0000099>            CALL "C$PID" USING PID.
       .0000100.            DISPLAY "PID = " PID.
       .0000101.     *      CALL "C$DEBUG"
       .0000102.            ACCEPT W-SYS-DATE FROM DATE.
       .0000103.            MOVE W-SYS-YY TO CURR-YY.
       .0000104.            MOVE W-SYS-MM TO CURR-MM.
       (cobcdb)

Notice the character after the line number. While it is usually ., if it is >, this indicates the line is the current debugger line.

Where:

  • start is the line number of the source file where the list is to begin.
  • stop is the line number of the source file where the list is to end.

<start>|<stop>|List begins|List ends |-----|----|-----------|---------| | | |at the current debugger line minus 5|at the current debugger line plus 5| |start| |at line start minus 5|at line start plus 5| |+start| |at the current debugger line minus 5 |at the current debugger line plus start| |-start| |at the current debugger line minus start minus 5| at the current debugger line minus start plus 5| |*| |at the first line of the source file |at the last line of the source file| |start|stop|at line start |at line stop| |+start|stop|at the current debugger line minus 5|at line stop| |-start|stop|at the current debugger line minus start| at line stop| |*|stop|at the first line of the source file |at line stop| |start|+stop|at line start|at line start plus stop| |+start|+stop|at the current debugger line minus 5| at the current debugger line minus 5 plus stop| |-start|+stop|at the current debugger line minus start|at the current debugger line minus start plus stop| |*|+stop|at the first line of the source file|at line stop plus 1| |start|*|at line start| at the last line of the source file| |+start|*|at the current debugger line minus 5|at the last line of the source file| |-start|*|at the current debugger line minus start|at the last line of the source file| |*|*|at the first line of the source file|at the last line of the source file|

next

next causes execution to pass to the next statement, jumping over a CALL or PERFORM statement before breaking, unless the CALL’ed paragraph or PERFORM statement contains a breakpoint. An event-next command is issued. This is interrupted when an –event-end-stepping-range event takes place. The next command can be abbreviated as “n”.

Example: 

       (cobcdb)
       next
       -event-next
       -event-end-stepping-range (cobcdb)#0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!17

print <variable-name\> displays the value of the variable in human readable format.

Example: 

       print message-line
       $1 = @hello.WORKING-STORAGE.message-line [11]"XXXXXXXXXXX"
       (cobcdb)

The information returned is in the format:

$1=@module-name.section-name.variable-name[size]"[string]"

Where:

  • module-name is the program-id of the module being executed.
  • section-name is the section containing the variable being displayed.
  • size is the size, in bytes of the variable.
  • string is the contents of the variable in human-readable format.

printh <variable-name>

printh <variable-name> displays the value of the variable in hexadecimal format.

Example: 

       printh message-line
       $1 = @hello.WORKING-STORAGE.message-line [22]"5858585858585858585858"
       (cobcdb)

The information returned is in the format:

$1=@module-name.section-name.variable-name[size]"[string]"

Where:

  • module-name is the program-id of the module being executed.
  • section-name is the section containing the variable being displayed.
  • size is the size, in bytes of the variable.
  • string is the contents of the variable in hexadecimal format.

quit

quit causes an exit from the debugger.

Example: 

       (cobcdb)
       quit

       C:\COBOL\COBOLIT\samples>

replace

To locate a source file that has been moved, and associate it with an object compiled for debug, use the replace debugger command, which changes the path to the source file.

The syntax is as follows:
replace <oldprefix> : <newprefix>

The replace debugger command allows you to replace the location where the source files associated with the program being debugged are stored.

The replace debugger command replaces any prefix of the full pathname, so the command replace /dirA : /dirB will allow any program that was originally compiled in /dirA/dev/sources to have its source stored in /dirB/dev/sources.

Subsequent commands are stacked, so when typing two more commands as follows:

  replace /dirC : /dirD
  replace /dirE : /dirF

you will end up with a list of three possible replacements. Only the first matching replacement will be executed.

Further usages include:

  • replace <no arguments> Resets the list, removing active replacements
  • replace ? Produces a list of active replacements.

Note

The replace debugger command only affects the output of the list command. The list debugger command allows you to expand the source you can see inside the console debugger as you execute your debugger commands.

run <command-line-arguments>

The run command will set the command line arguments available from ACCEPT FROM COMMAND LINE and then allow the program to continue to run. It is best used immediately after the program begins debugging and after break points are set.)

       (cobcdb)
       -event-end-stepping-range .0000008>        MAIN SECTION.
       #0 EXAMPLE () at C:/example.cob!8
       list
       .0000003.        ENVIRONMENT DIVISION.
       .0000004.        DATA DIVISION.
       .0000005.        WORKING-STORAGE SECTION.
       .0000006.        01 PARAMETERS                   PIC X(80).
       .0000007.        PROCEDURE DIVISION.
       .0000008>        MAIN SECTION.
       .0000009.            ACCEPT PARAMETERS FROM COMMAND-LINE.
       .0000010.            DISPLAY PARAMETERS.
       .0000011.        END-MAIN.
       .0000012.            STOP RUN.
       (cobcdb)
       br !9
       Breakpoint 1 at C:/example.cob ! 9
       (cobcdb)
       run abcd efgh
       (cobcdb)
       -event-breakpoint-hit .0000009>            ACCEPT PARAMETERS FROM COMMAND-LINE.

set

set allows the user to set a <set parameter> to a different value.

The set command requires a <parameter>.

Parameters for the set command are:

Parameter Description
prompt <prompt-string> Sets the debugger prompt to <prompt-string>.
var <variable-name> <variable-value> Sets the value of <variable-name>.
varh <variable-name> <variable-value> Sets the value of <variable-name> in hex notation.

set machine [off]

set machine is an internal command that controls how the debugger responds to input. The off option disables command.

set maxdata <maximum-data-length>

set maxdata sets the maximum length of a data item to print via a info var <variable-name>command (and others). Data items that are longer than <maximum-data-length> will be truncated to that length.

set profiling [dump] [on|off]

set profiling will enable and disable profiling of the current program. The dump option is commentary. The off option will turn off profiling. The on option will turn off profiling.

The set profiling command will respond with the new start of profiling, as will as not specifying an option.

Example:

      (cobcdb)
       event:18244
       -event-end-stepping-range .0000008>        MAIN SECTION.
       #0 EXAMPLE () at C:/Example/example.cob!8
       (cobcdb)
       set profiling
       profiling dump to file is off
       (cobcdb)
       set profiling on
       profiling dump to file is on
       (cobcdb)
       set profiling off
       profiling dump to file is off

set prompt <prompt string>

set prompt <prompt string> sets the COBOL-IT Debugger prompt. The default setting for the COBOL-IT Debugger prompt is (cobcdb).

Example: 

       (cobcdb)
       event:13556
       -event-end-stepping-range #0 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!9
       set prompt >>>
       >>>

set readline [off]

The GNU ReadLine library provides a set of functions for use by applications that allow users to edit commands as they are typed in. Not all environments supports ReadLine.

set readline will enable the use of ReadLine when it would be otherwise disabled.

The off option can be used to disable the use of ReadLine.

set region <region-number>

set region sets the currently active region to region-number. If region-number is not valid, an error message will be displayed.

Example:

       set region 0
       R0 EXAMPLE () at C:/Example/example.cob!8
       (cobcdb)
       set region 2
       error:non active region number.

set sources [off]

set sources controls the automatic display of a source line by the debugger when certain events occur, such as when a breakpoint is encountered.

The off option will disable this behavior. Also usage of the off option will disable the use of the ReadLine. (See set readline off.)

set term [<terminal-name>]

set term, if the environment supports ReadLine, will set the ReadLine terminal name parameter and initialize ReadLine to use it.

set trace [on|off|<trace-filename>]

set trace controls the tracing that cobcdb produces. The trace is a log of all the inputs and outputs of the current debug session after the trace is enabled until it is disabled.

Note

The trace file will be emptied every time tracing is enabled.

The options to the trace command are:

Option Meaning
On If tracing is not currently enabled, enables tracing to a file with the name cobcdb.out.
Off Discontinues tracing to the current trace file.
<trace-filename> Enables tracing to a file with the name trace-filename.

set var <variable-name> <variable-value>

set var <variable-name> <variable-value> sets variable content for variable-name to variable-value. Values are converted to the appropriate type. A number stored in a PIC 999 field will be converted before storing.

Example: 

       (cobcdb)
       set var message-line "hello hello"
       $1 = @hello.WORKING-STORAGE.message-line [11]"hello hello"
       (cobcdb)

set varh <variable-name> <variable-value-hex>

set varh <variable-name> <variable-value-hex> sets variable content for variable-name to variable-value-hex.

<variable-value-hex> must be a valid hexadecimal string. Note that in a valid hexadecimal string, a single character space is recorded with two characters, so the total string length of <variable-value-hex> must be exactly two times the length of <variable-name>.

Example: 

       (cobcdb)
       set varh ws-dummy 41
       $1 = @hello.WORKING-STORAGE.ws-dummy [1]"A"
       (cobcdb)

step

step causes execution of the program to execute a single step, and then break. An event-step command is issued. This is interrupted when an –event-end-stepping-range event takes place. The step command can be abbreviated as “s”.

Example: 

       (cobcdb)
       step
       -event-step
       (cobcdb)-event-end-stepping-range #0 hello () at 
       C:/COBOL/COBOLIT/samples/hello.cbl!14

stop

stop causes execution to stop (break) at the next statement.

thread

thread causes the current thread number and its thread id to be displayed.

Example:

       -event-end-stepping-range .0000009>            ACCEPT PARAMETERS FROM COMMAND-LINE.
       #0 EXAMPLE () at C:/Example/example.cob!9
       thread
       [Current thread is 1 (thread 22192)]
       (cobcdb)

tty

tty redirects the input and output of a COBOL program to an different serial device. This command is only available on UNIX and is only available when the debugger is started without an initial program name on the command line.

It is equivalent to the --tty command line option.

up -[n]

up -[n] changes the current frame. When you have several levels of CALLs, the info functions relate to the current module. In a CALL’ed subprogram, up –[n] can be used to change the frame back to a previous CALL’ing module. Info locals can then be viewed for that calling module.

In the example below, the bt command shows 3 frames, with frame 0 being the current frame in a called sub-program, and the info locals command showing the state of the variables in the subprogram. up -1 sets the frame to the calling program, so that info locals can be viewed for the calling program.

       bt
       #0 subpgm () at C:/COBOL/COBOLIT/samples/subpgm.cbl!7
       #1 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!25
       #2 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!17
       (cobcdb)
       info locals
       @subpgm.WORKING-STORAGE
              @subpgm.WORKING-STORAGE.RETURN-CODE = [10]"+000000000"
              @subpgm.WORKING-STORAGE.TALLY = [10]"+000000000"
              @subpgm.WORKING-STORAGE.SORT-RETURN = [10]"+000000000"
              @subpgm.WORKING-STORAGE.NUMBER-OF-CALL-PARAMETERS = [10]"+000000000"
              @subpgm.WORKING-STORAGE.COB-CRT-STATUS = [4]" "
       (cobcdb)
       up -1
       #1 hello () at C:/COBOL/COBOLIT/samples/hello.cbl!25
       (cobcdb)
       info locals
       @hello.WORKING-STORAGE
              @hello.WORKING-STORAGE.RETURN-CODE = [10]"+000000000"
              @hello.WORKING-STORAGE.TALLY = [10]"+000000000"
              @hello.WORKING-STORAGE.SORT-RETURN = [10]"+000000000"
              @hello.WORKING-STORAGE.NUMBER-OF-CALL-PARAMETERS = [10]"+000000000"
              @hello.WORKING-STORAGE.message-line = [11]"XXXXXXXXXXX"
              @hello.WORKING-STORAGE.ws-dummy = [1]" "
              @hello.WORKING-STORAGE.ctr = [6]"000000"
              @hello.WORKING-STORAGE.COB-CRT-STATUS = [4]"0000"
       (cobcdb)

version

version returns the version of the cobcdb/COBOL-IT runtime.

Example: 

       (cobcdb)
       version
       ~"COBOL-IT cobcdb 3.6.4\n"
       ^done
       (cobcdb)

whatis <parameter>

whatis provides type information on the supplied parameter.

The parameter may be:

Parameter Type Information
<variable> The data type of the variable. (See below.)
<label> void()

Data Types - char * - COB_GROUP - COB_BOOLEAN - COB_NUMERIC - COB_NUMERIC_BINARY - COB_NUMERIC_PACKED - COB_NUMERIC_FLOAT - COB_NUMERIC_DOUBLE - COB_ALPHANUMERIC