JP3141817B2 - How to check the function interface - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program logic rationality check, and more particularly to a function interface check method for checking the rationality of a program function interface between partial load modules not subjected to linker processing. .

[0002]

2. Description of the Related Art Conventionally, rationality of the check of the function name used at the time of function calls between functions that exist on a different part load module, did not can be performed by a linker. This
Because of the creation of the address link to the call function is to hand
In this case, it is necessary to create an address link.
There was a problem that an error occurred in certain cases. Check for this error
In order to output the program, a method has been adopted in which a program to be inspected is actually run on a target machine, and an error in use of a function name is detected from an abnormal phenomenon caused by contradiction. Also, use of function parameter names when calling functions
Rationality check has not been conducted
For this reason, a method has been adopted in which a program to be inspected is actually run on a target machine and an error in use of a function parameter name is detected from an abnormal phenomenon caused by contradiction.

[0003] Checking the rationality of setting a function parameter when a function is called between functions complicates checking by a compiler and a linker.
A method has been adopted in which a program to be inspected is actually run on a target machine, and an error in the presence or absence of setting of a function parameter is detected from an abnormal phenomenon caused by contradiction. FIG. 6 is an explanatory diagram showing a situation at the time of a function call between functions in the related art. When a function call is performed in a transmission function 81 of a transmission partial load module 80, transmission parameter information 82 is stored in a reception load module. The data is transferred to the receiving side function 91 of 90. Therefore, a check on the function interface, that is, a check on rationality regarding the setting of the function name, parameter name, and parameter for the function to be called is not performed.

[0004]

As described above, conventionally, when an error in using a function name, an error in using a function parameter name, and an error in setting a function parameter are respectively detected, a program to be inspected is actually executed on a target machine. And a method of detecting an error in using a function name, an error in using a function parameter name, and an error in setting a function parameter from a phenomenon caused by the contradiction. However, in this method, the abnormal phenomena caused by the contradiction occur after running the program for a considerable number of steps after passing the point where the error exists, and then the abnormal phenomena appear. The cause of the error cannot be easily searched for. For this reason, when there is an error in the use of the function name, the use of the function parameter name, and the setting of the function parameter, the detection of the error involves a difficult operation and is troublesome despite a simple error. There was a problem. Therefore, an object of the present invention is to easily detect an error in the use of a function name, the use of a function parameter name, and the setting of a function parameter when the error occurs.

[0005]

SUMMARY OF THE INVENTION In order to solve such a problem, the present invention detects an error in the use of a function name, the use of a function parameter name, and the setting of a function parameter, and immediately detects the error. By notifying the error, the error detection is facilitated, and has the following means. That is, the transmitting function transmits the function key information generated from the function name to be called at the time of the function call to the called receiving function,
In the receiving function, the received function key information is compared with the function key information generated from the receiving function name by a function key information check routine, and when a mismatch is detected, a failure notification of the program is performed. Also, the sending function sends the parameter key information generated from the parameter name of the function to be called at the time of the function call to the called receiving function, and the receiving function generates the parameter key information from the received parameter key information and the parameter name of the receiving function. This is a method of comparing the obtained parameter key information with a parameter key information check routine to notify a failure. Also, at the time of the function call, the transmitting side function transmits parameter setting key information that turns on the flag when a parameter is set to the called receiving side function, and the receiving side function transmits the received parameter setting key information and the receiving side function. In this method, the parameter setting key information generated from the parameter definition described above is compared with a parameter setting key information check routine, and a failure notification is performed. When the function is called from the sending function, the receiving function returns parameter setting key information that turns on the flag when the return parameter is set to the sending function at the end of the function call to the sending function. , The transmitting function compares the returned parameter setting key information with the parameter setting key information generated from the parameter definition of the call target function by the parameter setting key information check routine,
This is a method of notifying a failure.

[0006]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention will be described below with reference to the drawings. FIG. 1 is an explanatory diagram for explaining a method of checking a function interface according to the present invention, in which two partial load modules 10 and 20 are used, and a transmitting function 11 on a transmitting partial load module 10 is used as a receiving partial load module. FIG. 3 shows an example of a case where a reception-side function 21 on 20 is called.

When the transmitting function 11 calls the receiving function 21, not only the transmitting parameter information 13 but also the transmitting key information 12 for checking the normality of the inter-function interface is provided. Is passed to the receiving-side function 21. When receiving the transmission-side function key information 12, the reception-side function 21 compares the transmission-side function key information 12 with the reception-side key information 22 held by the user using the key information check routine 23. Then, the inter-function interface is assumed to be normal, and the processing is continued. If they do not match, the inter-function interface is regarded as abnormal, and fault information of the program is immediately notified to the tester through a terminal or the like.

Further, at the end of the function call, the receiving side function 2
Numeral 1 indicates the receiving side key information 22 as reply information and the transmitting side function 1
Reply to 1. The transmitting-side function 11 compares the returned receiving-side key information 22 with the transmitting-side key information 12 by using the key information check routine 15. If they match, the inter-function interface is assumed to be normal and processing is continued. For example, the inter-function interface is determined to be abnormal, and the tester is notified of the fault information of the program on the spot through a terminal or the like.

FIG. 2 is a diagram showing a detailed example of key information, parameter information, a key setting routine, and a key check routine when the transmitting function 11 calls a function. FIG. 3 is a diagram showing an example of details of key information, a key check routine, and a key setting routine in the reception-side function 21 when a function is called. FIG. 4 is a diagram illustrating a coding example of a transmission-side function 50 that performs a function call. FIG. 5 is a diagram illustrating a coding example of the receiving-side function 70 to be called.

FIG. 4 shows an example in which the transmitting side function 50 in FIG. 4 calls the receiving side function 70 in FIG.
Shows an example in which the function 70 is called by the transmitting function 50 in FIG. The key information and the routine information shown in FIG. 2 are examples of the key information and the routine information when the transmitting function 50 in FIG. 4 calls the receiving function 70 in FIG. The information and the routine information are as follows: the receiving function 70 in FIG.
An example of key information and routine information when a function call is made to 0 is shown.

The details of a method for creating key information will be described below with reference to FIGS. The value of the key information, the receiving side setting key information, the key information checking routine, and the key information setting routine are generated by a compiler.
That is, when the program is compiled by the compiler, the compiler generates a value of key information, a value of key setting key information, a check routine of key information, and a key information setting routine from the coded statement.

The sender-side setting key information is not generated by the compiler. The sending-side setting key information value is set when the program actually runs by a key information setting routine generated by the compiler. The key information is for checking the identity between the pieces of information corresponding to the key information. Therefore, the key information may be generated from the information corresponding to the key information by the same method and the same rule.

In this example, the key information is generated by adding all the ASCII code values of the characters having names corresponding to the key information. The function key is generated by adding the ASCII code of the function name character. The parameter key is generated by fully adding the ASCII code of the parameter field name character and the ASCII code of the parameter attribute name character.

In FIG. 2, the function key 30 on the transmission side is a function name "func" of the call destination designated by the line position 62 in FIG.
2 ". The ASCII code of each character of “func2” at the line position 62 is fully added to obtain the key information value “47”.
8 "is obtained. In FIG. 2, the transmission-side parameter key 31
Are generated using the parameter definition names at the row positions 52, 58, 55, and 56 in FIG. In order to improve the accuracy of the check, the key information is generated not only with the field name but also with the attribute definition of the parameter.

The key information value of the first parameter “p1d” is obtained by adding the value “2” of the parameter name “p1d” at the row position 52 to “2”.
The key information value “592” is obtained by adding the addition value “331” of the attribute definition “int” to “61”. Similarly, the key information value of the second parameter “p2d” is obtained by adding the added value “262” of the parameter name “p2d” at the row position 58 and the added value “42” of the attribute definition “*” to “304”. Get.
The key information value of the third parameter “p3d” is the row position 55
The addition value “263” of the parameter name “p3d” and the addition value “414” of the attribute definition “char” are added to “67”.
7 ". The key information value of the fourth parameter “p4d” is the sum “2” of the parameter name “p4d” at the row position 56.
"678" is obtained by adding the added value "414" of the attribute definition "char" to "64".

As described above, in the parameter key information, the key information is created in consideration of not only the parameter name but also the attribute definition, so that not only an error in the parameter name but also an error in the attribute definition can be detected. . FIG.
In, the receiving side function key 40 is generated from the receiving side function name “func2” at the row position 71 in FIG. Row position 7
The key information value “478” is obtained by adding the ASCII code of each character “func2” of “1”.

In FIG. 3, the receiving side parameter key 41
Are generated from the parameter definition names and the parameter attribute definition names at the row positions 72, 77, 75, and 76 in FIG. First
The key information value of the parameter “p1d” is obtained by adding the addition value “261” of the parameter name “p1d” at the row position 72 and the addition value “331” of the attribute definition “int” to obtain a key information value “592”. Similarly, the second parameter “p2
The key information value of “d” is the parameter name “p2
d ”and“ 4 ”of the attribute definition“ * ”
2 "to obtain" 304 ". The third parameter “p
The key information value of “3d” is the parameter name “p” at the row position 75.
The addition value “263” of “3d” and the addition value “414” of the attribute definition “char” are added to obtain “677”. The key information value of the fourth parameter “p4d” is the addition value “264” of the parameter name “P4d” at the row position 76 and the attribute definition “ch”.
The addition value “414” of “ar” is added to obtain “678”.

In FIG. 2, "son" of "p1,""p2," and "p3" of the transmission-side parameter setting keys 32 are not generated by the compiler. The compiler generates a setting routine for setting a setting key. “P1”, “p2”, “p3” of the transmission-side parameter setting key 32
"Son" indicates that the line position 5 in FIG.
It is generated by a setting key setting routine embedded immediately after each of the statements 9, 60 and 61.

The "son" of the first parameter "p1" is generated by the setting key setting routine embedded immediately after the statement "p1 = 10" at the line position 59 is executed. Similarly, the second parameter “p2”
Is the statement "p2 = &
After the execution of "p2a", it is generated by the setting key setting routine embedded immediately after that. The “son” of the third parameter “p3” is generated by the setting key setting routine embedded immediately after the statement “p2-> p3d = 30” at the line position 61 is executed. Here, “son” means that transmission parameter information has been set.

In FIG. 2, “ron” of “p4” of the transmission-side parameter setting key 32 is generated by the compiler based on the input / output specification of the parameter definition at the line position 56 in FIG. Here, since the fourth parameter “p4” is specified as “in” at the row position 56, “ron” is generated. “Ron” means that the reply parameter information is set.

In FIG. 3, “son” of “p1,” “p2,” and “p3” of the reception-side parameter setting key 42 is
It is generated by the compiler based on the input / output specification of the parameter definition at the line positions 73, 77, and 75 in FIG. First
Since the parameter “p1” is specified as “in” at the line position 73, “son” is generated. Since the second parameter “p2” is specified as “in” at the line position 77,
"Son" is generated. Since the third parameter “p3” is specified as “in” at the row position 75, “son” is generated. Here, "son" means that transmission parameter information is set.

In FIG. 3, "ron" of "p4" of the receiving-side parameter setting key 42 is not generated by the compiler. The compiler generates a setting routine for setting a setting key. Receiving-side parameter setting key 4
The “ron” of “p4” of No. 2 is generated by the setting key setting routine embedded immediately after the statement “p2-> p4d = 40” at the line position 78 is executed when the program is executed. In FIG. 2, the transmission-side parameter 33 is actual parameter information transmitted and received between the transmission-side function 50 and the reception-side function 70 at the time of a function call.

Next, details of a method of generating the key setting routine and the key check routine will be described with reference to FIGS. Here, the key setting routine has a function of setting the corresponding parameter setting key information when the parameter information is set. The key check routine has a function of determining whether both pieces of key information to be checked match.

In FIG. 2, when the statements at the line positions 59, 60, and 61 are respectively executed in FIG. 4, the parameter setting key setting routine 34 sets “P1”, “P2”, The routine is such that the parameter setting key flag of “P3” becomes “son” and is generated by the compiler. In the setting routine, the function part that sets “p1” to “son” immediately after the row position 59, the function part that sets “p2” to “son” immediately after the row position 60, and “p3” sets “son”. The function part to be executed is embedded immediately after the row position 61. Here, the “son” flag means that the transmission parameter has been set.

In FIG. 2, when the execution of the function call at the row position 62 in FIG. 4 is completed, the parameter setting key check routine 35 is executed by the reception parameter setting key 42 which is the return information from the reception function 70 of the call destination. "p4d"
A routine for checking "on", generated by the compiler. The check routine is the sender function 50
Is embedded in a position immediately after the function call statement at line position 62 in the line.

In FIG. 3, a function key check routine 43 is a routine for checking the transmission side function key 30 transmitted when the reception side function 70 of FIG. 5 is called and executed. Generated by The check routine is embedded at the processing start position in the receiving side function 70. In FIG. 3, a parameter key check routine 44 is a routine for checking the transmitted transmission-side parameter key 31 when the reception-side function 70 of FIG. 5 is called and executed, and is generated by a compiler. . The check routine is embedded at the processing start position in the receiving side function 70.

In FIG. 3, a parameter setting key check routine 45 is a routine for checking the transmitted parameter setting key 32 transmitted when the receiving function 70 shown in FIG. 5 is called and executed. Generated by the compiler. The check routine is embedded at the processing start position in the receiving side function 70. In FIG. 3, the parameter setting key setting routine 46 is a routine in which, when the statement at the line position 78 in FIG. 5 is executed, the parameter setting key flag “P4” of the receiving side parameter setting key 42 becomes “ron”. , Generated by the compiler. The setting routine is performed by the receiving function 70.
Is embedded immediately after the statement at line position 78. Here, the “ron” flag means that the return parameter has been set.

Next, details of the flow of the key information check processing at the time of a function call will be described with reference to FIGS. FIG.
, The execution of the transmission-side function 50 is started.
When the execution of the function progresses and the “p1 = 10” statement at line position 59 is executed, the setting routine embedded immediately after that causes the transmission-side parameter setting key 32 in FIG.
The [son] flag is set to "p1" of the. Similarly,
When the statement of “p2 = & p2a” at the line position 60 is executed, [so] is added to “p2” of the transmission-side parameter setting key 32 by a setting routine embedded immediately thereafter.
The "n" flag is set. "P2->p3" at line position 61
When the statement of “d = 30” is executed, the “son” flag is set in “p3” of the transmission-side parameter setting key 32 by the setting routine embedded immediately after that. As described above, the parameter setting key is set when the corresponding parameter is actually set.

Here, if "p1 =" in row position 59 in FIG.
If the statement of "10" was omitted,
Since no corresponding setting routine is generated, FIG.
"So" of "p1" of the transmission-side parameter setting key 32
n ”is not set, and when a function call is executed,“ s ”is checked by the parameter setting key check in the called function.
"on" is checked, and a check error occurs due to "son" mismatch, and a program failure is notified.

When the execution of the function further proceeds and “func2 (p1, p2)” at line position 62 in FIG. 4 is executed,
Not only the transmission-side parameter 33 in FIG. 2 but also the transmission-side function key 30, the transmission-side parameter key 31, and the transmission-side parameter setting key 32 set during execution of the function are passed to the reception-side function 70 in FIG. It is. When the function call is executed, the process execution shifts from the calling transmitting function 50 to the called receiving function 70.

Before the processing in the self-function is started, the called function 70 uses the key check routine in the self-function to determine the transferred key information and the key information in the self-function. Check the comparison. If they match, the function processing is executed continuously, but if they do not match, the fault information of the program is output to the terminal immediately using an interrupt, the tester is notified, and the function processing is continued. Will do. Receiver function 70 called
Before starting the processing in the self-function, the key information value “478” of the delivered transmission-side function key 30 and the key of the reception-side function key 40 included in the self-function are used by using the function key check routine 43. The value is compared with the information value “478”. In this example, since the values are the same, the comparison results match, and the process proceeds to the next process without notification of failure as normal check.

Similarly, the reception-side function 70 continuously uses the parameter key check routine 44 to set “p1d + in” of the delivered transmission-side parameter key 31.
t ”,“ 304 ”of“ p2d ++ ”,“ P ”
"677", "p4d + char" of "3d + char"
"678" and the receiver-side parameter key 4 in its own function
“592”, “p2d ++” of “p1d + int” of No. 1
"304", "P3d + char""677",
"678" of "p4d + char" is compared. In this example, since all values are the same, the comparison results match,
The process proceeds to the next process without notification of a failure as a normal check.

Further, the receiving-side function 70 continuously uses the parameter setting key check routine 45 to send “p1” “son”, “p2” “son”, and “p3” of the transmitted transmitting-side parameter setting key 32. ”
n ”and“ son ”of“ p1 ”,“ son ”of“ p2 ”, and“ p ”
3 is compared with “son”. In this example, since all plants are the same, the comparison results match, and the process proceeds to the next process without notification of a failure as normal check.

Here, the transmitting side function 50 is replaced by the receiving side function 70
The key information values of 30 and 31 passed to are generated from the function names and parameter names defined in the transmitting function 50, while the key information values of 40 and 41 held by the receiving function are stored in the receiving function. It is generated from the defined function name and parameter name. Therefore, if the function name and the parameter name are incorrectly defined in the transmitting function 50, the receiving function 70
If the definition is different from the function name and parameter name defined in, the key information value generated thereby differs between the transmitting side and the receiving side. For this reason, in such a case, when the key information is checked at the time of the function call, the key information does not match, and a setting error of the function name and the parameter name can be detected from the mismatch information.

In the examples of FIGS. 2 to 5, there are no errors in the function name and the parameter name, so that the transmission side key information value in FIG. 2 and the reception side key information value in FIG. 3 all match. . However, if the parameter definition name is incorrect from “p1d” to “pxd” at the line position 53 of the transmitting side function 50, for example,
The first parameter key of the transmission-side parameter key 31 in FIG. 2 is “pxd + int” instead of “p1d + int”, and the key information value is “639” instead of “592”. As a result, when the key information is checked at the time of executing the function call, the key information value on the transmitting side and the key information value on the receiving side are different. "Px
d "can be detected.

Normally, inconsistencies in the definition names often result in functional misinterpretation of the definition names, rather than simply erroneous definition names. For this reason, even if it is a simple definition name check, if it is executed, it can be a trigger for detecting a functional error. Therefore, detection of a functional error can be expected by executing a simple definition name check.

The parameter setting key has a flag on the parameter receiving side as to whether or not the parameter should be set, and the setting flag is turned on when the parameter is actually set on the parameter transmitting side. By checking whether these two setting flags match when executing a function call, an attempt is made to detect a setting omission of a transmission parameter. If the detection of this parameter setting omission is attempted by a logic check of a static program by a compiler or a linker, the check becomes complicated and it is difficult to realize the check. However, if the forgotten parameter setting is dynamically detected during the execution of the program as in this example, the detection check can be easily performed.

In FIG. 5, when the execution of the check processing of the key information at the time of calling the function is completed, the reception side function 70 starts executing the processing in the function itself. Processing progresses, and “p2-> p4” at the row position 78 of the reception-side function 70
When the statement of “d = 40” is executed, “ron” is set to “p4” of the reception-side parameter setting key 42 in FIG. 3 by the setting routine embedded immediately after that. Here, “ron” means that data is set in the fourth parameter.

Further, the execution in the receiving side function 70 proceeds,
When the processing of the called function 70 is terminated,
If there is parameter return information to the transmission-side function 50 that called the function, parameter setting key information corresponding to the parameter return information is returned in addition to the parameter return information. Here, “ron” of “p4” of the reception-side parameter setting key 42 in FIG.

When the processing of the receiving function 70 is completed and the execution of the processing is returned to the transmitting function 50 that made the function call, the transmitting function 50 has a case where there is reply parameter information from the receiving function 70 of the call destination. Before restarting the self-function processing, check the parameter setting key information corresponding to the return parameter information. The transmitting side function 50 uses the parameter setting key check routine 35 to execute the receiving side function 7.
“P” of the receiving-side parameter setting key 42 returned from
The “ron” of “4” and the “ron” of “p4” of the transmission-side parameter setting key 32 are compared and checked.

If they match, the processing is continued as normal, and if they do not match, it is regarded as abnormal and fault information of the program for detecting the error is output to the terminal device on the spot using an interrupt. In the case of this example, since the values are the same, the comparison results match, the check is normal, and the process proceeds to the next process without notification of a failure.

If the row position 78 of the receiving function 70
If the setting of the fourth parameter is omitted, the setting routine corresponding to the setting is not generated, so that "ron" is not set in "p4" of the receiving-side parameter setting key 42, and the setting key information in the case of feedback is returned. If the check indicates that the setting key information does not match, the setting omission of the fourth parameter can be detected.

As described above, according to the present invention, key information is created for a function name, a parameter name, and parameter setting presence / absence information for a function that calls a function and a function that is called a function. By comparing the key information created by both parties at the time of executing the function call, errors in the function name, parameter name, and presence / absence of parameter setting, which are function interface information, are detected. In other words, the transmitting function that makes a function call generates function key information corresponding to the call target function name from the call target function name at the time of compilation, and this function key information uniquely corresponds to the function name. On the other hand, in the called receiver function, the function key information corresponding to the receiver function name and the function key information check routine for checking the function key information received at the time of the function call from the receiver function name are provided. Generated at compile time. Then, when executing the function call, the transmitting function on the calling side transfers the function key information generated from the name of the function to be called to the receiving function on the called side together with the parameter information. In the receiving function, the function key information generated from the receiving function name is compared with the drawn function key information using the function key information check routine, and if they match, the function call is normal and the processing is continued.
If they do not match, as a function call error, program failure information for detecting the error is output to a terminal device (not shown).

Similarly, in the case of the parameter key information, in the transmitting function on the calling side, the parameter key information is generated at the time of compilation from the definition name of the parameter of the function to be called. In the called receiving side function, parameter key information corresponding to the parameter definition name of the receiving side function and a parameter key information check routine for checking parameter key information received at the time of function call are generated at compile time. You. Then, at the time of executing the function call, the transmitting side function on the calling side transfers the parameter key information generated from the definition name of the parameter of the function to be called to the receiving side function together with the parameter information. In the receiving function, the function parameter key information generated from the parameter definition name of the receiving function is compared with the passed function parameter key information using the parameter key information check routine. The process is continued, and if they do not match, a function call error is detected, and fault information of a program for detecting the error is output to the terminal device.

In the case of parameter setting key information,
In the calling function, the parameter setting key information setting routine that turns on the setting flag when the immediate data is set to the corresponding parameter instead of the variable, and the parameter based on the parameter definition of the function to be called Setting key information and a parameter setting key information check routine for checking parameter setting key information are generated at the time of compilation. And
In the called function of the called side, the parameter setting key information based on the parameter definition of the receiving function, the parameter setting key information check routine for checking the parameter setting key information, and the corresponding return parameter And a parameter setting key information setting routine that turns on the setting flag when immediate data is set.

Here, at the time of executing the function call, the calling function sends the parameter setting key information together with the function parameter information. The called function on the called side compares the received parameter setting key information with the parameter setting key information generated from the parameter definition of the receiving function using the parameter setting key information check routine. Processing is continued as normal, and if they do not match, failure information of a program for detecting an error is output to the terminal device as a function call error. At the end of the function call, the called function on the called side passes the parameter setting key information together with the return parameter to the calling function on the calling side. The sending function compares the returned parameter setting key information with the parameter setting key information generated from the parameter definition of the function to be called by the parameter setting key information check routine. And if they do not match, the failure information of the program for detecting the error as a function call error is output to the terminal device.

[0047]

As described above, according to the present invention, the normality of the function name interface is automatically checked on the spot based on the function key information received by the receiving function at the time of the function call, and the function name interface is incorrect. In this case, the error event is notified to the tester at that time, so that the error can be easily detected. Also, the function parameter name interface is automatically checked on the spot based on the parameter key information received by the receiving function at the time of the function call, and if the function parameter name interface is incorrect, the error event is tested at that point. In this case, the error can be easily detected. In addition, the normality of the function parameter setting interface is automatically checked on the spot based on the parameter setting key information received by the receiving function at the time of the function call, and if the function parameter setting interface is incorrect, the error event Since the tester is notified, an error can be easily detected similarly. Also, at the end of the function call, based on the parameter setting key information returned from the receiving function, the transmitting function automatically checks the normality of the function parameter setting interface on the spot, and if the function parameter setting interface is incorrect, Since the error event is notified to the tester at that time, the error can be similarly easily detected.

[Brief description of the drawings]

FIG. 1 is a functional block diagram showing a main configuration of the present invention.

FIG. 2 is a diagram illustrating a function of a transmission-side function.

FIG. 3 is a diagram illustrating a function of a reception-side function.

FIG. 4 is a diagram illustrating a coding example of a functional operation of a transmission-side function.

FIG. 5 is a diagram illustrating a coding example of a functional operation of a reception-side function.

FIG. 6 is a functional block diagram showing a conventional configuration.

[Explanation of symbols]

10, 20: partial load module, 11: transmission side function, 12: transmission side key information, 13: transmission side parameter information, 14, 24 ... key information setting routine, 15, 23 ...
Key information check routine, 21 ... Reception side function, 22 ...
Reception key information, 30: transmission function key, 31: transmission parameter key, 32: transmission parameter setting key, 3
3 ... transmission side parameters, 34, 46 ... parameter setting key setting routine, 35, 45 ... parameter setting key check routine, 40 ... reception side function key, 41 ... reception side parameter key, 42 ... reception side parameter setting key, 43
... function key check routine, 44 ... parameter key check routine.

──────────────────────────────────────────────────続 き Continued on the front page (58) Field surveyed (Int.Cl. ⁷ , DB name) G06F 11/28-11/36 G06F 9/40 G06F 9/45 G06F 11/08

Claims (2)

(57) [Claims] 1. A method for checking an interface between function parts of each program module, comprising a plurality of program modules each having a function part. Sends the function key information generated from to the function part of the receiving module to be called, and in the function module of the receiving module, checks the received function key information and the function key information generated from the receiving function name. A method for checking a function interface, comprising comparing by a routine and notifying a failure of a program when a mismatch is detected. 2. A method for checking an interface between function parts of each program module, comprising a plurality of program modules each having a function part. The parameter key information generated from the parameter name is sent to the function part of the receiving module to be called,
The function part of the receiving module compares the received parameter key information with the parameter key information generated from the parameter name of the receiving function by the parameter key information check routine, and notifies the program of a failure if a mismatch is detected. A method for checking a function interface characterized by the following.