JPH0831036B2 - Program upward compatibility guarantee method - Google Patents

Description

[Detailed Description of the Invention] [Outline] Regarding a program upward compatibility guarantee method for maintaining compatibility with old functions and expanding functions, maintaining compatibility with applications using old functions and updating new functions For the purpose of providing a program upward compatibility guarantee method that can be easily performed, in a program having a function interface in which another program can use the function of the program by the function CALL, the parent program can execute the function call before the function call. And a use level declaring means for declaring a use level of each function, and a processing program for executing processing of each function for the parent program, managing the function level of the function, and declaring by the use level declaring means of the parent program. Level management table means for storing a function level for each function and the parent program If it is Luo function call,
Level checking means for checking the level of each function set in the level management table by the usage level declaring means with reference to the level management table means, and a function corresponding to the declared level are processed and declared. And a processing unit for returning the result corresponding to the level to the parent program side and returning the result, and the processing program side is configured to perform the processing corresponding to the function level requested by the parent program.

[Industrial applications]

The present invention relates to a function expansion method for a program having a function interface, and more particularly to a program upward compatibility guarantee method for maintaining compatibility with old functions and expanding functions.

Generally, a program is composed of a main program and subroutines such as functions and procedures. In the main program,
By executing the function CALL, for example, the process moves to a function type subroutine and is executed in a form of returning to the main program after the completion of the subroutine. A program that uses a function of a program, that is, a function function executed in a subroutine by calling a function of another program, that is, a main part of an application program, is called a program having a function interface. Structured programming methods such as C language and Pascal language have many function interfaces. In this way, in a program that has a function interface, the number of changes to the main application program is reduced,
Moreover, it is becoming more important to upgrade the function function.

[Conventional technology]

Conventionally, when a program having this kind of function interface expands the function, the first method that uses the function whose contents are expanded from the function having the same name as the function defined in the past,
There is a second method in which a new function having a different name is prepared for each level in which the function is expanded and both the old function and the new function can be used.

[Problems to be Solved by the Invention] When the first method of calling a function with the same name is used,
If the function or interface of the function with the same name is significantly different, the extended function can be used, but the application incorporating the function of the old function defined in the past cannot be used. .

In addition, the second function that prepares a new function with a different name for each level upgrade
With this method, there are a large number of functions with similar functions on the application side, which is the main program, and it is necessary to rewrite all the corresponding function names when the application level is upgraded. However, there is a problem that the possibility of making a correction error increases.

It is an object of the present invention to provide a program upward compatibility guarantee method that can maintain compatibility with an application that uses an old function and can easily update a new function.

[Means for solving the problem]

 FIG. 1 is a block diagram of the principle of the present invention.

In a program having a function interface in which other programs can use the function of the program by the function CALL, the use level declaring means 2 declares the use level of each function before the parent program 1 calls the function.

In the processing program 3 that executes the processing of each function for the parent program 1, the level management table means 4
The function level of the function is managed, and the function level declared by the use level declaration means 2 of the parent program 1 is stored for each function.

When the function is called from the parent program 1, the level check means 5 checks the level of each function set in the level management table 4 by the use level declaration means 2 with reference to the level management table means 4.

The returning processing means 6 processes the function corresponding to the declared level, returns the result corresponding to the declared level to the parent program side, and executes the processing corresponding to the function level requested by the parent program 1 as a processing program. Perform on the 3rd side.

[Action]

According to the present invention, a processing program having a function interface is provided with a "level management table" for holding the levels of functions used by an application in a table format, and functions called by the application when the function is called from the application. The level is checked by the "level management table" and the processing corresponding to the level is performed to assure the upward compatibility of the program.

〔Example〕

 Next, an embodiment of the present invention will be described with reference to the drawings.

FIG. 2 is a conceptual diagram of the program upward compatibility guarantee system of the present invention. In the figure, 1'is an application program and 3 is a processing program as a subroutine. In the present invention, the level management table 4 for holding the function levels used by the application, that is, the parent program in a table format is provided in the processing program having the function interface, that is, the processing program that constitutes the function on the subroutine side. Then, when the function call from the application, that is, the function CALL is performed, the function level requested by the application is checked by the level management table 4, and the processing corresponding to the corresponding level is performed in the processing program 3 to improve the upward compatibility of the program. Guarantee. For example, it is assumed that there are functions A, B, C, etc., and that each function has three functions corresponding to level 1, level 2, and level 3. Here, level 1 includes basic functions, level 2 is added to the basic functions by adding α, and level 3 is added to level 2 by adding α, which is added. I shall. Here, it is assumed that the functions are expanded in the order of level 1, level 2, and level 3. According to the method of the present invention, the function usage level of a function is declared before the function is called in the application program so that the function level can be selected from the parent program of the application program. On the other hand, the processing program 3 on the subroutine side has a level management table 4 for managing the usage level of the function, and sets the value of the usage level declaration from the application in the table when the application declares the usage level. . For example, when the function A uses the level 2, the level 2 is stored, when the function B uses the level 3, the level 3 is stored, and when the function C uses the level 1, the level 1 is stored. This is the declaration of the usage level in the application program and the setting of the level value in the level management table in the processing program.

Since the application program is on the main program side, when calling a function, call it as a CALL statement. Therefore, the function is called from the application while the application program is being executed. For example, assume that the function A is CALL as shown in. Then, the execution shifts to the processing program 3. However, in the processing program 3, the content of the level management table 4 is always checked and the level of the called function A is checked before the processing program is executed as indicated by. Since this level has already been declared earlier in the application program and contains a level number equal to that value,
This level can be retrieved from the level management table 4. For example, when the function A is CALL, the level management table 4 reads out that the level of the function function A is 2. Therefore, the execution of the function A of the processing program 3 will be performed at the level 2 below. Level 2 is implemented as the basic function of function A plus α. Then, in level 2, the processing of level 2 is performed, and the return of the result corresponding to this level 2 is sent to the application side and returned. Thus, in the present invention, when a function is called from the application in the present invention, the processing program checks the corresponding function level in the level management table 4 and performs the processing corresponding to the function in. In this way, the function name on the application side is the same, and in the processing program, the parts common to each level can be commonly used, and only the upgraded one can be used according to the level declaration. . Furthermore, not only the old function and the new function can be selected according to the level, but also the correction amount of the processing program or the correction error can be reduced.

FIG. 3 is an embodiment diagram for explaining the program upward compatibility guarantee system of the present invention. In the figure, 1'is an application program and 3 is a processing program. When the function A and the function B are used in the application program 1 ', the function A is 3 from level 1 to level 3.
There are two levels, and the function B has two levels, level 1 and level 2. Level 1 of function A is parameter x
Only level can be specified, and level 2 has parameters x and y
Can be specified, and level 3 has parameters x, y,
It is assumed that z can be specified. That is, it is assumed that the function A of level 1 is a function of argument x, the function A of level 2 is a function of x and y, and the level 3 is a function of x, y, and z. When executing a function, the dummy argument is given as an actual argument with a specific value before calling this function in the parent program, the processing program for this actual argument is executed in the subroutine side, and then the value of the function is returned. Be done. Further, with respect to the function B, the arguments are the same between level 1 and level 2, but the value of the function returned to the parent program side is different,
At level 1, the variable p is returned as a result, and at level 2, p and q are returned. First, when the application program is executed, the usage level is declared in 2. As an example, it is assumed that function A declares level 2 and function B declares level 1. Then, the level management table 4 is installed on the processing program 3, and the declared level value is set in the level management table 4. Therefore, the function A is set to level 2, and the function B is set to level 1. Subsequently, the application program 1 is executed. During this execution, first, the function A is CALLed. Function A
Then, level 2 is executed, but it is assumed that only y is set as a parameter on the application side. Level 2 says that the parameters x and y can be specified, but if only y is set for the parameter, the actual argument for the parameter x is not defined. However, even in this case, if the function A can be executed, the processing program can execute the processing by using only the parameter of y and perform the processing corresponding to the level. Therefore, the function A
If CALL is specified and only y is specified, the processing program 3 first checks the level management table 4 to check the level of the function A, and if it is confirmed that the level is 2, it corresponds to the level 2. Perform the process to be performed and return the result at the time of return.

Next, it is assumed that the application program 1'calls the same function A during execution. At this time, it is assumed that z is specified as a parameter. Since the function A of level 2 can specify only x and y as parameters, it becomes an error to specify z. Therefore, when the function A is CALLed and the execution control is transferred to the processing program 3, the processing program 3 first checks the level of the function A using the level management table 4 and confirms that it is level 2. In this level 2, it can be seen that x and y can be designated as parameters, and that if z is designated, it is a mistake. Therefore, the processing program 3 notifies that there is an error in the designation, that is, the error is sent to the application 1'on the parent program 1 side. That is, when the level 2 is executed by the function A, the parameter z is not supported, and therefore the error is returned.

Further, in this case, the function B will be called. Since the level 1 is declared in the function B, the processing program 3 is executed when the routine is transferred to the processing program 3.
First, the level management table 4 is checked and the function B is level 1
Make sure that In the processing routine of the function B, the same thing is executed in level 1 and level 2, but level 1
Then, only p is returned as a result, and level 2 has the difference that p and q are returned as a result. Therefore, on the processing program 3 side, when the function B is CALL, p and q are generated as the result of the processing regardless of the level.
Since level 1 is specified now, processing program 3
Returns only p as a variable corresponding to level 1 out of the resulting p and q. That is, when returning to the application program, only the resulting p is returned and returned. When the level of the function B is level 1, q is not supported, so even if q is included in the processing result, it will not be returned.

In the present invention, as described above, the function of the program is changed by another program, that is, the application program.
In a program that has a function interface that can be used by CALL, an interface is provided for expanding the function while maintaining compatibility with the old function.

〔The invention's effect〕

According to the present invention, it is possible to minimize the influence on the application program due to the function expansion of the program having the function interface. further,
Even if the functions of the processing program are expanded, there is no need to modify the application that incorporates the functions corresponding to the old functions, and even if the application expands the functions,
It is possible to reduce the correction amount and the correction error.

[Brief description of drawings]

FIG. 1 is a block diagram of the principle of the present invention, FIG. 2 is a conceptual diagram of a program upward compatibility guarantee system of the present invention, and FIG. 3 is an embodiment diagram for explaining the program upward compatibility guarantee system of the present invention. 1 ... Parent program, 2 ... Usage level declaration means, 3 ...
... processing program, 4 ... level management table means, 5
...... Level check means, 6 ... Return processing means.

Claims (2)

[Claims] 1. A program having a function interface in which a parent program can use the function of a processing program by a function CALL, wherein the parent program (1) declares a usage level of each function before calling the function. A processing program (3) including a level declaring means (2) for executing processing of each function for the parent program (1) manages the function level of the function, and uses level declaring means () of the parent program (1). Level management table means (4) for storing the usage level declared by 2) for each function, and the usage level declaring means (2) when the function is called from the parent program (1). A level check for checking the level of each function set in the level management table (4) by referring to the level management table means (4). And a processing unit (6) for processing the function corresponding to the declared level, returning the result corresponding to the declared level to the parent program side, and returning the result. A program upper compatibility guarantee method, wherein processing corresponding to a function level requested by a parent program (1) is performed on the processing program (3) side. 2. The program upward compatibility guarantee system according to claim 1, wherein the parent program is an application program developed by a user.