JPH04101237A - Debug processing system - Google Patents

Abstract

PURPOSE:To execute the debug of a program by an interpreter by executing the dynamic call of the program processed into a dynamic call type when it is detected that the interpreter calls the program of an object type from the program of an intermediate language type. CONSTITUTION:A compiler 102 to convert a source program into the program of the intermediate language type, the interpreter 104 to execute that program of the intermediate language type, and a linker 103 to process the subprogram of the object type into the program of the dynamic call type are provided. Then, when it is detected that the interpreter 104 calls the program of the object type from the program of the intermediate language type, the dynamic call of the program processed into the dynamic call type is executed. Thus, the program of the object type is called dynamically from the program of the intermediate language type, and the program debug is easily executed through the interpreter.

Description

[Detailed Description of the Invention] [Field of Industrial Application] This invention is applicable to existing piled object-format C0BOL subprograms and object-format subprograms in languages other than C0BOL in which intermediate language cannot be created. In debugging and executing a COBOL main program that calls and uses , the present invention relates to a debug processing method that calls and executes the subprogram as it is without modifying the logic of the main subprogram for debugging.

[Conventional technology]

C0BOL calls subprogram from interpreter
When debugging a program, subprograms must be written in intermediate language. Existing object format programs are not generated in intermediate language format, so they cannot be executed by an interpreter. Therefore, when executing a program that calls an existing object-format subprogram or a subprogram created in a language other than C0BOL using an interpreter, modify the logic in the subprogram call part so that it does not call, and temporarily store the result in the call parameter. By adding assignment processing, etc., the processing was executed in a chain as if calling a subprogram.

[Problem to be solved by the invention]

When using an interpreter to debug or execute a C0BOL program that calls and uses existing object-format subprograms or subprograms created in other languages, the main program's subprograms cannot be executed using the interpreter. The problem is that you need to modify the calling logic to prevent the call from occurring, and at the same time add processing to assign the result to the call parameter.

[Means to solve the problem]

The debug processing method of the present invention includes a compiler that converts a source program into an intermediate language format program, an interpreter that executes the intermediate language format program, and a linker that processes an object format subprogram into a dynamically called program. and is configured to dynamically call a program processed into a dynamic call type when the interpreter detects that an object format program is being called from an intermediate language format program.

Further, the debug processing method of the present invention is realized by using an interpreter to debug an intermediate language program that calls a dynamically called program as a subprogram.

〔Example〕

Next, the present invention will be explained with reference to the drawings.

FIG. 1 is a schematic diagram of an execution environment showing an embodiment of the present invention. In the figure, 101 is a compiler that creates an object format program.

Object format programs are generally created as needed, regardless of program execution by an interpreter, and stored in a library. A compiler 102 creates a program as an intermediate language program to be executed by an interpreter. A linker 103 processes an object format program into a dynamic call type program and stores it in a dynamic call type library. The interpreter 104 will be described later.

FIG. 2 is an explanatory diagram showing the execution process of the interpreter.

At (201), the interpreter loads the debug target program in intermediate language format into memory.

At (202), the interpreter starts executing the program one instruction at a time.

When executing the CALL instruction in the program (203), the interpreter recognizes the name of the called subprogram and requests O8 to search for a dynamic call type library and make a dynamic call request.

At (204), dynamic calling is performed to load the subprogram into memory.

At (205), parameters are set for the subprogram and the subprogram is called.

At (20B), the subprogram performs predetermined processing and returns to the interpreter.

At (207), the return parameters from the subprogram are passed to the main program.

(208) continues processing the main program, and
Execution continues from the instruction following the L instruction.

The main program ends at (209).

〔Effect of the invention〕

As described in detail above, according to the debug processing method of the present invention, an object format program can be dynamically called from an intermediate language format program, so that the program can be easily debugged through an interpreter.

[Brief explanation of the drawing]

FIG. 1 is a schematic diagram of an execution environment showing an embodiment of the present invention, and FIG. 2 is an explanatory diagram showing the operating procedure of an interpreter. 101...Object generation compiler, 1o2...
・Intermediate language generation compiler, 1o3...Linker, 1゜4
...Interpreter.

Claims (1)

[Claims] 1. A compiler that converts a source program into an intermediate language format program, an interpreter that executes the intermediate language format program, and a linker that processes object format subprograms into a dynamically called program. and a debugging process characterized in that when the interpreter detects that an object format program is called from an intermediate language format program, dynamically calls a program processed into a dynamic call type program. method. 2. The debugging method according to claim 1, wherein debugging of an intermediate language program that calls a dynamically called program as a subprogram is executed by an interpreter.