KR19990041418A - How to Generate Object-Oriented Fill Debugging Information - Google Patents

Abstract

The present invention relates to a method for generating Object Oriented CHILL (OO-CHILL) debugging information. The present invention relates to generating debugging information at each stage of program translation and integrating it in language execution code. A step of generating object-oriented program line information and task information in the transformed CHILL program, and integrating the information, thereby converting into a non-object-oriented language at compile time like OO-CHILL compiler and retranslating it into machine language. This has the effect of generating debugging information efficiently in a compiler with.

Description

How to Generate Object-Oriented Fill Debugging Information

The present invention relates to a method for generating OO-CHILL debugging information in a compiler using an Object Oriented CHILL (hereinafter referred to as OO-CHILL) to CHILL converter.

The present invention is to efficiently generate the debugging information required for the object-oriented CHILL program test in the program compilation step in a system using a general-purpose operating system.

Debugging information generation methods applied in all conventional compilers can directly embed debugging information for an object-oriented program in the assembly code because the compiler generates assembly code without converting from an object-oriented program to a non-object-oriented program.

However, the compiler that converts an object-oriented program into a non-object-oriented language and converts it back to an assembly language has a problem that the existing debugging information generation method cannot be applied.

These compilers need to generate debugging information during both program changes and to integrate information between them.

In order to solve the above problems, the present invention, in order to efficiently generate the debugging information in the OO-CHILL compiler using the OO-CHILL to CHILL converter and the CHILL to machine code generation method, Its purpose is to provide a method of generating and a method of integrating this information.

1 is a hardware block diagram according to the present invention,

2 is a detailed process flow diagram for generating OO-CHILL program debugging information to which the present invention is applied;

3 is a detailed process flow diagram for generating debugging information in the OO-CHILL to CHILL step according to the present invention,

4 is a detailed process flow diagram for generating debugging information in the CHILL to machine code step according to the present invention,

<Description of Symbols for Main Parts of Drawings>

101: central processing unit 102: main memory

103: auxiliary storage device 104: input and output device

105: system bus

In order to achieve the above object, the present invention, in the OO-CHILL to CHILL translation step, object-oriented information analysis and information generation of the OO-CHILL program, and in the CHILL to machine code step of translating the generated CHILL program into machine language Analyzing the CHILL code to generate the object-oriented program line information and task start information, and integrating the generated debugging information into the corresponding code.

Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

1 is a general block diagram of a hardware configuration according to the present invention, in which a central processing unit 101, a main memory 102, an auxiliary memory 103, and an input / output device 104 are connected to each other by a system bus 105. It is a system with a general operating system.

The OO-CHILL to CHILL converter and the CHILL to machine code converter are mounted in the main memory 102 of the host system, executed in the central processing unit 101, and output and error messages are inputted and outputted through the input / output device 104. Messages sent and received between devices are made via the system bus 105, and the general-purpose operating system controls programs and devices.

The auxiliary memory 103 stores an OO-CHILL execution file, code and debugging information generated in each conversion step, and files and tools not mounted in the main memory 102.

2 is a detailed process flow diagram for generating the OO-CHILL program debugging information to which the present invention is applied, and the debugging information generating method according to the present invention will be described below.

First, an OO-CHILL source file is received as an input (S1) to generate OO-CHILL information, and a corresponding CHILL file is generated (S2).

The generated CHILL file is used as an input to generate an assembly code including the process / procedure and source line information of the CHILL program (S3).

After generating the assembly code, the two debugging information are integrated (S4), and the object-oriented debugging information is included with the assembly file including the OO-CHILL debugging information, CHILL procedure / process, and line information generated in each step. Create an executable file (S5).

Executables written in this manner can be used as input to a commercial object-oriented debugger to debug at the source level.

3 is a detailed process flow diagram for generating debugging information in the OO-CHILL to CHILL step according to the present invention, and shows a process of generating debugging information in the OO-CHILL to CHILL step of FIG.

The OO-CHILL source file is taken as input (S2a) and the program is parsed to form an OO-CHILL abstract syntax tree (hereinafter referred to as AST) (S2b).

The OO-CHILL variable name and structure information, which is internal information of the AST, are determined (S2c).

After determining the OO-CHILL variable name and structure information, it is determined whether the code generation is completed (S2d), and when it is completed, the execution code generation including the OO-CHILL debugging information is terminated (S2e).

If the code generation is not completed after the determination, the file and the basic mode information is generated (S2f), the line information is generated (S2g), and it is determined whether the information is a data declaration statement (S2h).

After the determination, in the case of the data declaration statement, the object-oriented data information is generated (S2i). If the data declaration statement is not the task start statement (S2j), the task start statement and the task start information and task information are generated (S2k). The code is generated (S2l) and the process returns to the code generation completion determination (S2d).

4 is a detailed process flow diagram for generating debugging information in the CHILL to machine code step according to the present invention. The CHILL source file is taken as an input (S3a) and the program is parsed to construct a CHILL AST (S3b). ), And determine the CHILL variable name and structure information that is the internal information of the AST (S3c).

After finalizing the CHILL variable name and structure information, it is determined that the code generation is completed (S3d), and when it is completed, the execution code including the CHILL debugging information is generated (S3e).

After the determination, if the code generation is not completed, generate line information (S3f) and determine whether the generated information is a task start statement (S3g), and if it is a task start statement after determination, generate task start information (S3h), or execute code (S3i) and return to the code generation completion determination (S3d).

The executable code including the OO-CHILL debugging information is generated by integrating the OO-CHILL debugging information file generated in the above two steps with the execution code including the CHILL debugging information.

As described above, the present invention has an effect of efficiently generating debugging in a compiler having a process of translating into a non-object oriented language and retranslating it into machine language, such as the OO-CHILL compiler.

Claims (3)

In a compiler using the OO-CHILL to CHILL converter, how to generate OO-CHILL debugging information: A first step of receiving the OO-CHILL source file as an input to generate OO-CHILL information and a corresponding CHILL file; A second process of generating an assembly code including a process / procedure and source line information of a CHILL program by inputting the generated CHILL file; A third step of integrating two debugging information after generating assembly code; Method for generating object-oriented fill (OO-CHILL), characterized in that for generating an executable file including the object-oriented debugging information using the generated OO-CHILL debugging information, CHILL procedure / process, line information assembly files . The method of claim 1, wherein the second process A first step of accepting an OO-CHILL source file as input to parse a program and construct an OO-CHILL abstract syntax tree (AST); Determining a OO-CHILL variable name and structure information which is internal information of the AST; Determining whether the code generation is completed after the determination of the OO-CHILL variable name and structure information, and when the code generation has been completed, terminating execution of execution code including OO-CHILL debugging information; A fourth step of generating file and basic mode information, generating line information, and determining whether the information is a data declaration if code generation is not completed after the determination; A fifth step of generating object-oriented data information in the case of the data declaration statement after the determination, or generating task start information and task information in the case of the task start statement after determining the task start statement; If it is not the task start statement after the determination, after generating the execution code, the object-oriented fill (OO-CHILL) debugging information generation method characterized in that it comprises a sixth step of returning to the code generation determination. The method of claim 1, wherein the third process is A first step of accepting the CHILL source file as input, parsing the program and configuring CHILL AST; Determining a CHILL variable name and structure information which is internal information of the AST; A third step of generating and executing execution code including CHILL debugging information when the CHILL variable name and the structure information are determined and determined to complete the code generation; A fourth step of generating line information if the code generation is not completed after the determination and determining whether the generated information is a task start statement and generating task start information if the task start statement is generated; If the information generated after the determination is not a task start statement, generating an execution code and returning to the code generation completion determination;