Debugging a project containing C and COBOL - Micro Focus

Mixed-Language Debugging of projects containing C and COBOL
Net Express and other Micro Focus software development tools offer a wide range of possibilities to
construct COBOL projects. Of course, programs written in different languages like C can be added to such
a project. However, if such a mixed language project is to be debugged with the Micro Focus Animator, as
well as with the C debugger, several restrictions have to be taken into account when designing the project.
If the project consists only of COBOL programs, it can be animated in INT, GNT and EXE/DLL forms with
Net Express. If there are C modules, however, these C modules must be linked as an EXE or DLL. Here a
decision has to be made. Shall the same EXE/DLLs contain both the C and COBOL objects or only objects
from one language? Both are possible, but when an EXE or a DLL contains both, you can debug either
the C functions or animate the COBOL programs.
To enable real mixed language debugging, i.e. debugging C and COBOL on the same application execution
requires a different design. All COBOL programs, which are desired to be debugged, must be compiled to
INT format.
How can C functions and COBOL programs interface each other?
1 A C main program and COBOL subprograms (which themselves can call C subprograms, …)
2 A COBOL main program, which call the C functions (which themselves can call COBOL
subprograms, …)
The C programs/functions must be compiled and linked to EXEs or DLLs. But a C function cannot directly call
a COBOL INT. An interface module is necessary, which is written in COBOL and compiled into an OBJ. This
.OBJ can be placed into a separate DLL or linked together with the C functions into a single EXE or DLL.
Within the following example, a separate DLL is used. This is an easier methodology to use.
Before we look at the debugging, we have to know, how a call between C and COBOL can be
executed.
Calling C from COBOL
1. A COBOL INT program can call a C function, where the C function is linked into the DLL, after the DLL is
loaded into memory. This load can be performed by a SET-Statement or by a CALL statement towards the
name of the DLL. Afterwards the call can be executed.
Special-Names.
Call-Convention 520 is C-CALL.
*> 520 = static link + upper/lower case like written
Working-storage section.
01 PP usage is Procedure-Pointer value NULL.
SET PP to entry “C_DLL.dll ”.
IF PP = NULL
Display “ C_DLL.dll could not be loaded into memory ”
Stop run
End-IF.
Call C-CALL “My_C_Function ” *> using ...
2. The direct call of a C-function, i.e. without the “SET PP to entry …”, does work from COBOL
compiled to EXE/DLL, but not from an INT, which we need for debugging.
Page 1 of 6

Calling COBOL from C
For the opposite direction we have both possibilities, when calling a COBOL DLL, like the example
“interface.DLL” mentioned above.
1. The first possibility works in exactly the same way as the “Calling C from COBOL” from above and may
look like this:
#include
#include // for printf
void C_Function()
{
}
HINSTANCE myhdl;
FARPROC myproc;
myhdl = LoadLibrary("Interface.dll");
if(myhdl == 0) {
}
printf( “Interface.dll could not be loaded into memory “);
exit(1);
myproc = GetProcAddress(myhdl, "MY-COBOL-PROGRAM" );
(*myproc)();
2. The second possibility needs a LIB-file, which contains the export definitions of the COBOL .DLL. This
LIB is constructed when by the linking process, but is normally removed by Micro Focus. If the LIB file is
needed an option must be selected as follows.
If CBLLINK is used to link to DLL, add “-k” as option:
cbllink –d –k My-Cobol-Program.cbl
will compile and link a COBOL program appropriately.
If the Net Express IDE is used, right-click on the DLL, select “Build settings...”, chose the tab “Link” change
the “category” to “advanced” and check the “Keep temporary Linker files”. After a rebuild of the project, the
LIB file will remain in the debug (or release) directory.
This LIB file must be specified when linking the C OBJ files resp. included into the C project. It enables the C
functions to call directly a COBOL program.
void C_Function()
{
}
MY_COBOL_PROGRAM();
Page 2 of 6

Constructing a sample application
For the sample programs, I have use the IDE of Net Express 3.1 and Microsoft Visual C++ 6.0. Even the Net
Express IDE can be used to trigger the compile of the C programs, if a C compiler is installed, for debugging
C it is better to also construct a C project.
Now, change the following default in the Net Express IDE: In “Animate”, “Settings...”, in “Mixed Language
Debugging”, select “Enable mixed-language debugging and disable generated and linked code debugging”. If
you forget this, this Visual C debugger will stop at an unexpected “int 3” assembly instruction. This is the
debugger-interrupt, but it cannot be handled by two debuggers simultaneous.
1. In the following screenshot, my settings can be seen:
Start Animating at: MSDEV.exe Commandline Parameters: CandCOBOL.dsw
MSDEV.EXE is the Visual Studio debugger; CandCOBOL.dsw is the Visual C project file. In my demo, I start
the Visual Studio as the start program.
2. Alternatively, the EXE of the C-project can be used to start the application, but this requires a coded
breakpoint within the EXE. There will be a slight different behavior, when starting in project. See below.
Page 3 of 6

With this knowledge we can start to construct the projects.
C main program and COBOL subprograms
This is the C main-program and must linked as an EXE. An inline assembler instruction _asm{ int 3 } can be
used to invoke the debugger. Alternatively a DebugBreak()-Call can be programmed. However, the Debugger
will stop paradoxically at the assembly level when using the WinApi function and will stop on C level when
using the assembler function.
main()
{
}
_asm{ int 3 }
COB_Sub_interface();
This is the COBOL subprogram:
Program-id. “COB-Sub ”
Procedure Division.
display "This is COBOL_Subprog".
This is the interface, written in COBOL, and should be linked as a DLL.
It uses the Call-Convention 512 for entries from C, which means “respect upper/lower case”.
It does not use the main entrypoint, but defines the C-Interface for all additional entries.
Page 4 of 6

It contains an ENTRY-statement for each COBOL program called by C.
The Interface-module cannot be debugged by the animator. Display statements can be added if
necessary.
Program-id. Interface.
special-names.
call-convention 512 is C-
Interface.
local-storage section.
*> enables the interface to
be called recursively
procedure division C-
Interface.
main.
goback.
Entries Section.
Entry-1.
Entry "COB_Sub_interface"
call "COB_Sub". *> called by file name, not by Program-id.
goback.
COBOL main program and C subprograms
The COBOL part is exactly the sample “Calling C from COBOL” like above, when the C_DLL.dll can be
found via the PATH environment variable. Compile the COBOL as an INT.
The C part may look like follows. The _asm{ int 3 } invokes the C Debugger. Compile the function with
the C compiler. Don’t forget to export the function “My_C_Function” by a DEF file.
void My_C_Function()
{
}
_asm{ int 3 }
printf( “in a C DLL\n ”);
Invoking the COBOL Animator
The COBOL animator can be started by:
Starting the application form the Net Express IDE with function key F11
A call “CBL_DEBUGBREAK”
Setting a breakpoint with function key F9 and starting the program.
Invoking the C debugger
The C debugger can be started by:
Starting the application from Visual Studio with function key F10 or F11
A WinApi function DebugBreak();
An inline assembler instruction _asm{ int3 }
Setting a breakpoint with function key F9 and starting the program.
Page 5 of 6

Preparing the attached demo for a test run
Select here to download the set of demonstration files is attached to this article
1 To run this demo it is necessary to have both Net Express 3.1 and Visual C++ installed on the
computer. This demo ran with Visual Studio 6.0 (start program: MSDEV.exe) and with Visual Studio.NET
(start program: DEVENV.exe).
2 The demo was constructed in D:\Article\CandCOBOL, but it should also run from a different location.
3 Start the Net Express IDE by clicking on the NE project file COBOLandC.APP.
4 Rebuild the Net Express project by Rebuild-All
5 Start the Visual Studio by clicking on the VC project file: CandCOBOL.dsw. With Visual Studio .NET
let Visual Studio convert the project.
6 There are 2 projects within CandCOBOL.dsw. Rebuild both.
7 Closed Visual Studio.
Running the demo - part 1: C main program and COBOL subprograms
1 If MSDEV.exe from Visual Studio 6.0 is not reachable by PATH, open the Animator – Settings and
either add the required PATH to the start program or change the start program to “debug\CandCOBOL.exe”
like in the graphics above.
2 Start the Net Express project by F11
3 If you use Visual Studio as start program, you need to start the application again from Visual Studio.
If you use the CandCOBOL.exe as start program, Visual C will stop at the debugger breakpoint with an error
message in a similar style as the CBL-DEBUGBREAK message box, where you can chose to invoke the
debugger.
4 You can use to step with F10 through the application.
5 The debugging session will switch several times between the C debugger and the COBOL animator.
6 The last step from the C main function, it will call a COBOL program, which calls a C program, which
calls a COBOL program. Any part can be debugged. Step by step. (This makes the interface.dll recursive;
therefore it needs a local-storage section.)
7 On this step, please leave the C-function C_in_DLL_with_Breakpoint with F5 (go). Pressing F10 here
will debug the COBOL runtime on assembly level. Please set a breakpoint into
C_in_DLL_calling_COB_Sub_Sub(), if you want to stop there again.
Running the demo - part 2: COBOL main program with calls to C functions
1 The demo-run above contains this already. Instead starting the demo with F11, start the demo with
the program at COB_Sub_Complex.int. Click with the right mouse button on the left project site on this .int
and chose “Animate”.
2 Please leave the C-function C_in_DLL_with_Breakpoint with F5 (go). Pressing F10 here will debug
the COBOL runtime on assembly level. Please set a breakpoint into C_in_DLL_calling_COB_Sub_Sub(), if
you want to stop there again.
Page 6 of 6