JPH03212739A - Procedure subprogram developing system - Google Patents

Abstract

PURPOSE:To prevent the generation of overhead for accessing a procedure subprogram at the time of its execution by providing the developing system with a dummy argument analyzing part, a real argument analyzing part and type declaration sentence/ dynamic storage unit shared sentence forming/inserting part. CONSTITUTION:The real argument analyzing part 21 in an access program analyzing part 20 extracts the array name and size of an array specified as a real argument by an access program for the procedure subprogram stored in an undeveloped source program 300 to store then in the real argument information table 200. The program formation part 30 accesses the procedure subprogram, develops the subprogram to an access program only up to a certain degree and then starts up the type declaration sentence/dynamic storage unit shared sentence forming/inserting part 31. The inserting part 31 in a program formation part 30 forms a dynamic storage unit shared sentence among the type declaration sentence of a matched array specified as a dummy argument, the matched array specified as the dummy argument and an array specified as a real argument corresponding to the dummy argument by means of a pointer based upon information stored in a dummy argument information table 100 and a real argument information table 200.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method for expanding a procedural subprogram in a source program written in the FORTRAN language.

[Conventional technology]

Conventionally, in this type of procedural subprogram expansion method, if a consistent array exists in the formal argument of the procedural subprogram to be expanded, it is ignored and the procedural subprogram is called by the procedural program (hereinafter referred to as Such expansion was not performed because a fatal error would occur during translation by the compiler if it were expanded into the calling program.

[Problem to be solved by the invention]

In the conventional procedural subprogram expansion method described above, if a consistent array exists in the formal argument of a procedural subprogram,
Since the procedural subprogram is not expanded into the calling program, there is a drawback that overhead is incurred for the calling program to call the procedural subprogram during execution.

In view of the above-mentioned points, an object of the present invention is to make it possible to expand a procedural subprogram that includes a consistent array in a formal argument into a calling program, and to avoid the overhead of calling the procedural subprogram at runtime. The purpose of this invention is to provide a procedural subprogram expansion method that allows for

[Means to solve the problem]

The procedural subprogram expansion method of the present invention is based on FORTRA
In the procedural subprogram expansion method that expands a procedural subprogram in a source program written in the N language into a calling program, it is analyzed whether or not a consistent array exists in the formal argument of the expanded procedural subprogram. The formal argument analysis unit in the procedural subprogram analysis unit that extracts the array name and dimensions of the consistent array specified as a formal argument and stores it in the formal argument information table if there is a formal argument, and the formal argument of the procedural subprogram to be expanded. The actual argument analysis section in the calling program analysis section extracts the array name and dimensions of the array specified as the actual argument corresponding to the actual argument and stores them in the actual argument information table, and the formal argument analysis section stores them in the formal argument information table. based on the information stored in the actual argument information table by the actual argument analysis section and the information stored in the actual argument information table by the actual argument analysis section. A type declaration statement/dynamic in the program creation section that creates a dynamic storage unit sharing statement regarding the array specified as the corresponding actual argument and a type declaration statement for the dynamic storage-intensive sharing statement and inserts it into the calling program. It has a memory flower position shared sentence creation insertion section.

[Effect]

In the procedural subprogram expansion method of the present invention, the formal argument analysis section in the continuation subprogram analysis section analyzes whether or not a matching array exists in the formal argument of the procedural subprogram L to be expanded. extracts the array name and dimensions of the consistent array specified as a formal argument and stores it in the formal argument information table, and the actual argument analyzer in the calling program analyzer corresponds to the formal argument of the procedure subprogram to be expanded. The array name and dimensions of the array specified as an actual argument are extracted and stored in the actual argument information table, and the type declaration statement/dynamic memory shared statement creation and insertion section in the program creation section uses the formal argument analysis section to Based on the information stored in the argument information table and the information stored in the actual argument information table by the actual argument analyzer, the type declaration statement of the consistent array specified as a formal argument and the type declaration statement of the consistent array specified as a formal argument are A dynamic storage unit sharing statement regarding the array specified as an actual argument corresponding to the formal argument and a type declaration statement regarding the dynamic storage unit sharing statement are created and inserted into the calling program.

〔Example〕

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

FIG. 1 is a block diagram showing the configuration of an embodiment of the procedural subprogram expansion method of the present invention. The procedure subprogram expansion method of this embodiment consists of a procedure subprogram expansion program 1, a formal argument information table 100, an actual argument information table 200, and an expansion part source program (a procedure subprogram before being expanded into a calling program). The program includes a source program (source program) 300 and an expanded source program (source program after the procedure subprogram is expanded into a calling program) 400.

The procedural subprogram expansion program 1 includes a procedural subprogram analysis section 10 having a formal argument analysis section 11, a calling program analysis section 20 having an actual argument analysis section 21,
The program creation section 30 has a type declaration statement/dynamic storage unit shared statement creation and insertion section 31.

FIG. 2 is a diagram showing an example of the formal argument information table 100 created by the formal argument analysis unit 11. The formal argument information table 100 includes the number of formal arguments, the length of the formal argument,
It remembers the formal arguments.

FIG. 3 is a diagram showing an example of an actual argument information table 200 created by the actual argument analysis unit 21. The actual argument information table 200 includes the number of actual arguments, the length of the actual arguments, and
It remembers the actual arguments.

Next, the operation of the procedural subprogram development method of this embodiment configured as described above will be explained.

The procedural subprogram analysis unit 10 in the procedural subprogram expansion program 1 manually generates the expansion m1 source program 300.

The formal argument analysis section 11 in the procedural subprogram analysis section 10 analyzes whether or not there is a procedural subprogram whose formal argument includes a consistent array in the expansion section source program 300.

In this analysis, if there is a procedural subprogram that includes a consistent array as a formal argument in the expansion source program 300,
The formal argument analysis unit 11 extracts the array name and dimensions of the matching array specified as a formal argument in the procedure subprogram, and stores it in the formal argument information file 100 (creates a formal argument information table lOO).

Next, the actual argument analyzer 2 in the calling program analyzer 20
1 extracts the array name and dimensions of the array specified as an actual argument in the calling program for the relevant procedural subprogram (the procedural subprogram to be analyzed by the above-mentioned formal argument analysis unit 11) in the expansion unit source program 300. and stores it in the actual argument information table 200 (creating the actual argument information table 200).

The program creation unit 30 develops the procedural subprogram to a certain extent into a calling program, and then activates the type declaration statement/dynamic storage unit shared statement creation and insertion unit 31.

The type declaration statement/dynamic memory shared statement creation/insertion section 31 in the program creation section 30 specifies parameters as formal arguments based on the information stored in the formal argument information table 100 and the actual argument information table 200. Share the unit ↑a at runtime using a pointer between the type declaration statement of the consistent array specified as a formal argument, the consistent array specified as a formal argument, and the array specified as an actual argument corresponding to that formal argument. Create a dynamic storage unit coexistence statement and a type declaration statement related to the dynamic storage unit sharing statement (type declaration statement for variables used in the dynamic storage unit sharing statement), and call those statements in a program. Insert into.

The program creation unit 30 outputs the expanded source program 400 created by the above processing.

FIG. 4 is a diagram for specifically explaining the above operation (expansion of a procedural subprogram containing a consistent array as a formal argument), and shows an example of the expansion section source program 300 and the post-expansion source program 400. FIG.

The procedure subprogram expansion program 1 includes an expansion unit primitive program 300 in FIG. When the program 300) is input, the formal argument analysis unit 11 selects 5LJBROUTI in the subroutine subprogram 340.
The formal argument information table 100 is created based on the formal arguments in the NE statement 330. The formal argument information table 10 shown in FIG.
0 corresponds to this), the actual argument analysis unit 21 creates the actual argument information table 200 based on the 20th out of 32 CALL statements in the subroutine subprogram 310 (the third
The actual argument information table 200 shown in the figure corresponds to this).

The program creation unit 30 creates an expanded executable statement 430 (an executable statement in a subroutine subprogram 340 that is expanded into a subroutine subprogram 310 that is a calling program) (in this case, the name used in the expanded executable statement 430 is A name in subroutine subprogram 340 (such as "K") is replaced with an appropriate name (rK) so that the name does not overlap with a name used in subroutine subprogram 310.
99999 (a name not used for boat fishing). Therefore, a type declaration statement 431 is created incidentally). After the above processing, the program creation section 30 activates the type declaration statement/dynamic storage unit shared statement creation and insertion section 31.

The type declaration statement/dynamic storage unit shared statement creation/insertion unit 31 includes a formal argument information table 100 and an actual argument information table 200.
In order to match the type declaration statement 410 of the consistent array specified as a formal argument with the consistent array specified as a formal argument and the array specified as an actual argument based on the information stored in dynamic storage unit shared statement 420 (
rDYNAMICPOINTER (199998, B9
9999) J and 1199998=LOG (A) a statement composed of two statements J) and a type declaration statement 421 related to the dynamic storage unit shared statement 420 are created.

Furthermore, the type declaration statement/dynamic storage unit shared statement creation insertion section 31
inserts the created type declaration statement 410, dynamic storage unit sharing statement 420, and type declaration statement 421 into the subroutine subprogram 310, and creates an expanded source program 400 (the program creation unit 30 inserts the expanded source program 400 into the expanded source program 400). ).

〔Effect of the invention〕

As explained above, the present invention provides a formal argument analysis section, an actual argument analysis section, and a type declaration statement/dynamic storage unit shared statement creation and insertion section. It is possible to expand the procedural subprogram into a calling program, and it is possible to avoid the occurrence of an overhead for calling the procedural subprogram during execution.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention, FIG. 2 is a diagram showing an example of the formal argument information table in FIG. 1, and FIG. 3 is a diagram showing an example of the actual argument information table in the first round. FIG. 4 is a diagram showing an example of the expansion part source program and the expansion source program in FIG. 1. In the figure, l...Procedure gl program expansion program, 10
...Procedural subprogram analysis section, 11.. Formal argument analysis section, 20.. Calling program analysis section, 21.. Actual argument analysis section, 30.. Program creation section, 31.. Type declaration. Statement/dynamic storage unit shared statement creation insertion part, 100... Formal argument information table, 200... Actual argument information table, 300... Expansion part source program, 310... Subroutine subprogram (calling program), 320... CALL statement, 330... 5 UBROUTINE statement, 340... Subroutine subprogram (procedure subprogram to be expanded), 400... Source program after expansion, 10 420 ・ 421.431... Type declaration statement, ・Dynamic memory flower positional coexistence statement, 430 ・・Expansion executable statement.

Claims (1)

[Claims] In the procedural subprogram expansion method that expands a procedural subprogram in a source program written in the FORTRAN language into a calling program, it is analyzed whether or not a consistent array exists in the formal argument of the expanded procedural subprogram. The formal argument analysis unit in the procedural subprogram analysis unit that extracts the array name and dimensions of the consistent array specified as a formal argument and stores it in the formal argument information table if there is a formal argument, and the formal argument of the procedural subprogram to be expanded. The actual argument analysis section in the calling program analysis section extracts the array name and dimensions of the array specified as the actual argument corresponding to the actual argument and stores them in the actual argument information table, and the formal argument analysis section stores them in the formal argument information table. based on the information stored in the actual argument information table by the actual argument analysis section and the information stored in the actual argument information table by the actual argument analysis section. A type declaration statement/dynamic storage in the program creation section that creates a dynamic storage unit sharing statement regarding the array specified as the corresponding actual argument and a type declaration statement related to the dynamic storage unit sharing statement and inserts it into the calling program. A procedural subprogram expansion method characterized by having a unit shared statement creation insertion section.