JPH02148138A - Debugging information adding system - Google Patents

Abstract

PURPOSE:To correct a program in the level of original design information by adding names and row numbers of original parts before synthesis or the like as comment rows correspondingly to respective statements at the time of combining groups of skeletons, parts, peculiar processings, or the like to synthesize one program. CONSTITUTION:A program synthesizing part 3 successively takes out skeletons and parts, peculiar processings, or the like, which are called by these skeletons, from preliminarily generated groups of skeletons, parts, peculiar processings, or the like to synthesize statements in response to synthesis indication. A design information/parts/program correspondence table 4 is generated which corresponds to the synthesized program where names (ID) and row numbers of original skeletons, parts, peculiar processings, or the like before synthesis corresponding to rows of these synthesized statements are added as comment rows. Thus, comment rows are referred to perform correction in the level of original design information when the synthesized program is corrected at the time of debugging or the like.

Description

[Detailed Description of the Invention] [Summary] Regarding a debug information addition method that adds debug information to the description of a program after synthesis, the name (I) of the original component before synthesis is added to the program after synthesis.
D) The purpose is to add line numbers as comment lines and refer to them to make it possible to modify the original design information at the level of the original design information when modifying the program during debugging, etc. Skeletons, parts that will be called from now on, unique processes, etc. are extracted line by line from multiple clusters, and statements are synthesized.The lines of the statements after these synthesis are associated with each other, and the original skeleton, parts, specific processes, etc. Name (1
0) and line numbers added as comment lines, and is configured to output a program to which comment lines have been added after this synthesis.

[Industrial application field]

The present invention relates to a debug information addition method for adding debug information to the description of a program after synthesis. In program development and maintenance, in order to reuse existing program assets as much as possible, we extract functions (program logic) that can be used in common, and when developing programs, we identify mechanisms that can be reused and There is a need for more efficient debugging in development methods.

After modifying the program, it was necessary to manually find and modify the relevant part of the design document, or to perform maintenance using only the synthesized program without modifying the design document.

The present invention adds the name (ID) and line number of the original component before synthesis to the program after synthesis as a comment line, and refers to these to obtain the original design information when modifying the program during debugging or the like. It is intended to be modifiable at levels.

C. Problems to be solved by conventional technology and the invention] In the past, programs were synthesized by combining multiple blocks of functions that could be used in common, such as skeletons, parts, and unique processing.
This synthesized program is being debugged.

At this time, when the program after synthesis is modified, there is a problem in that even if an attempt is made to reflect the modified part in the original design document, it is difficult to easily determine which part it is. At this time, there is a problem that the synthesized program is out of synchronization with the design document. [Means for Solving the Problem] FIG. 1 shows a diagram of the principle configuration of the present invention.

In FIG. 1, the program synthesis unit 3 includes a skeleton,
Skeletons are created from multiple clusters of parts, specific processes, etc., and components that will be called from now on, specific processes, etc. are extracted line by line and synthesized into statements, and the original skeleton before synthesis corresponds to the line of the statement after these synthesis. Design information [/parts/
This is to synthesize program correspondence table 4 (corresponding to the program after synthesis).

It becomes possible to refer to the row and modify it at the stage of the original design information.

[Effect]

The present invention, as shown in FIG.
The program synthesis unit 3 sequentially extracts skeletons, parts, specific processes, etc. that will be called from now on line by line from a set of skeletons, parts, specific processes, etc. created in advance and synthesizes statements, and the lines of the statements after these synthesis. Design information/part/program correspondence table 4 (corresponding to the program after synthesis) with the names (IDs) and line numbers of the original skeletons, parts, unique processes, etc. before synthesis corresponding to them added as comment lines. I have to.

Therefore, the names (IDs) and line numbers of the original skeleton, parts, unique processes, etc. before synthesis are written as comment lines corresponding to the statements of the program after synthesis, so when debugging etc. Comments when modifying a program [Embodiment] Next, the configuration and operation of an embodiment of the present invention will be explained in detail using FIGS. 1 to 6.

In FIG. 1, a component generation unit 1 generates a design information/component correspondence table 2 based on design information (design specifications) (see design information/components correspondence table 2 in FIG. 4).

As shown in FIG. 5, the design information/component/program correspondence table 4 is a table in which correspondences between design information and programs, parts and programs, etc. are stored as shown.

Here, the constituent elements of the program, namely the skeleton, parts, and unique processing, will be explained using FIG.

In FIG. 2, the skeleton is the highest level element among the program components, and is an element that calls other elements but is not called by others.

Specific processing is processing that is used only by a certain program, and is composed of a data division and a procedure division.

A component is a process that is intended for reuse, and consists of one part of the data part and one part of the procedure part of the program.

An example of a program after synthesis according to the present invention will be described with reference to FIG.

In FIG. 3, the illustrated skeleton: 5KRTN.

The result of combining the three processes, unique processing: KOYLIU, and parts: BUHIN, is the combined program shown on the right.

As shown in the figure, this synthesized program has line numbers (in ascending order) at the left end, statements (commands) at the center, and comment lines between ☆ and ☆ at the right end. In the comment line, design information (names (ID) of skeletons, parts, unique processes, etc.) is written on the left side, and a line number is written on the right side.

Therefore, if you want to modify a statement on any line of the synthesized program during debugging, etc., you can use the original design information based on the number of lines and the skeleton name added to the comment line of the line you want to modify. It becomes possible to find and correct it, and to modify the program after synthesis.

The program after this synthesis is skeleton: 5KRT
For the first time from the first ■statement of N, ■call“
CALL KOYIIυ”
Like YUU statements, statements are taken out according to the flow of the program, and are synthesized in sequence by correlating them with line numbers.

The configurations shown in FIGS. 4 to 6 will be explained.

In the figure, the A° file stores information input on the table-format definition screen (table-format design image 10).

The C file is created by converting the information input in table format (table format design image 10) into YAC chart format, and adding line numbers ta) and defined screen information 佽) to correspond to each statement. It is for storing.

The A file is the YAC chart format definition screen (YAC
It stores the information input in the chart format design image 12.13).

The B file has line numbers fa) and ID(b) corresponding to each statement from the information in the YAC chart format.
l is added and stored.

The D file stores information indicating how to synthesize skeletons, parts, unique processing, and the like.

The E file combines and stores the information of the B file based on the information of the D file.

Next, the operation of the configuration shown in FIGS. 4 to 6 will be explained.

(1) From the screen of the tabular design image 10, for example, a check process (specific process) is created and stored in a file as shown in the figure. To be more specific, as shown in the column on the screen of the tabular design image 10, the data item name is "X", the lower limit is "1", and the upper limit is "10".
and store it in a file.

(2) Convert the check process from the table format to the YAC chart format using the component/specific process generation 11, insert the line number defined on the screen (al and the screen definition name in the mountain), and save it to the C file as shown in the figure. The design information/components correspondence table 2 is stored as follows.

(3) Also, design image 1 of YAC chart format
2, create part Q and store it in file A as shown. Similarly, a skeleton R is created from the screen of the design image 13 in the YAC chart format, and is stored in the A file as shown.

(4) Through the registration process 14, input the check process (specific process) from the C file, the part Q and the skeleton R from the A file, make them correspond to each statement, set the line number defined on the screen to fat, and set the ID to (t). ) and press B.
Store it in the file as shown.

(5) Through the synthesis instruction processing 15, the skeleton R1 part Q
, and how to combine check processing (specific processing) on the screen. The instructed information is stored in the D file as synthesis instruction information as shown in the figure. The information stored in this D file represents instructions for calling a check process and a component Q, which are unique processes for the skeleton R, respectively.

(6) Program generation 16 generates B file information (skeleton R1 part Q, check processing (specific processing)
) are combined into one program based on the combination instruction information in the D file, and stored in the E file as shown. As shown in the figure, this E file stores design information and programs, and parts and programs in association with each other.

(7) Synthesis program output 17 creates a program synthesized from the information in the E file (Synthesis YPS Specification 1
8) is output as shown.

(8) Due to synthesis yps specification 18, an error occurs when translating from a YAC chart to a C0BOL source, or from a C0BOL source to an executable source, and the line number targeted by the error message is displayed. In this case, according to this embodiment, as shown on the right side of the synthesis YPS specification 18, the definition screen name (check definition, part Q, etc.) and line number before synthesis are correlated on the list as debug information. Therefore, the design document (design image 10 in table format and design image 12.1 in YAC chart format)
3) can be corrected.

〔Effect of the invention〕

As explained above, according to the present invention, when a single program is synthesized by combining clusters such as skeletons, parts, and unique processing, the names and lines of the original parts before synthesis are associated with each statement. Since we have adopted a configuration in which numbers are added as comment lines, if you find an error in the program after synthesis, you can easily find the correction points in the original design information (skeleton, parts, unique processing, etc.) before synthesis. , modifications can be made based on the design information image. This makes it possible to perform program debugging and maintenance using the image of the design document, which greatly contributes to improving productivity and quality.

[Brief explanation of the drawing]

Fig. 1 is a diagram of the principle configuration of the present invention, Fig. 2 is an explanatory diagram of the skeleton, parts, and unique processing that are the constituent elements of the program, Fig. 3 is an example of the program after synthesis, and Figs. An explanatory diagram of the operation of the invention is shown. In the figure, 2 is a configuration information/parts correspondence table, 3 is a program synthesis section, 4 is a design information/parts/program correspondence table, 10 is a design image in table format, 11.12 is a design image in YAC chart format, 14 16 represents registration processing, and 16 represents program generation.

Claims (1)

[Claims] In a debug information addition method that adds debug information to the description of a program after synthesis, a skeleton, parts to be called, specific processes, etc. are sequentially executed from a plurality of clusters such as skeletons, parts, and specific processes. The statements are extracted in units and synthesized, and the names (I) of the original skeleton, parts, specific processing, etc. are
D) and a program synthesis unit (3) that synthesizes a program with line numbers added as comment lines, and is configured to output the program with comment lines added after this synthesis. method.