JPH06124216A - Program contradiction detection apparatus and method - Google Patents

Abstract

(57) [Summary] [Purpose] When developing a target application program by combining several program parts,
(EN) An apparatus and method for automatically verifying whether or not there is an inappropriate point in usage of a program component, that is, whether or not a program includes a contradiction, by utilizing the input / output relation of each program component. To aim. [Configuration] Component operation information indicating the operation of each program component and operation rules indicating what kind of state change the operation causes for each operation of each program component are stored in advance, and The connection relation is input, and the change in the operation state when each program component operates according to the connection relation is verified with reference to the component operation information and the operation rule. [Effect] Since an error in a processing procedure or a processing omission at the application level is automatically detected, the burden on the programmer is reduced and the productivity is increased.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program contradiction detection device and a program contradiction detection method for verifying consistency of application programs.

[0002]

2. Description of the Related Art Compilers and linkers have been known as conventional devices for verifying program consistency. When a compiler creates an object program from a source program, the compiler verifies that the source program conforms to the syntax and semantics of a particular programming language and notifies the programmer if any inconsistencies are detected. . In addition, the linker verifies whether or not all the other object programs referenced by each object program are complete when generating a single execution program by combining multiple object programs, and the missing object programs Notify programmer if there is.

[0003]

As described above, the consistency check at the programming language level is performed by the compiler or the linker, but the consistency check at the level closer to the application is not often performed. For example, when a target application program is developed by combining several program parts (for example, subroutines, functions, classes, etc.), even if the usage of the program parts is incorrect, a device that automatically detects them. Instead, the reality is that the programmer is doing the verification.

As an example of creating an application program by combining several program parts,
There is a program to perform withdrawal (withdrawal) processing of an automatic cash deposit / withdrawal machine. Such a program is often created by combining program parts that describe processing based on a certain screen. In this case, if you do not execute the program part that executes the insertion process of the cash card before executing the program part that executes the return process of the cash card, an error will occur because the card will be returned even if it is not inserted. To do. If the program component that executes the process of inputting the payout amount is not executed before executing the program component that executes the process of dispensing cash, the value that has not been input will be referenced in the same manner. The operation is strange. In the past, automatic detection of inconsistencies at a level close to such an application has not been performed so often.

In view of the problems in the above-mentioned conventional example, an object of the present invention is to utilize the input / output relation of each program part when developing an application program by combining several program parts. An object of the present invention is to provide an apparatus and method for automatically verifying whether or not there is an inappropriate point in the usage of program parts, that is, whether or not a program contains inconsistencies.

[0006]

In order to solve the above problems, the present invention is a program contradiction detection apparatus for detecting contradictions when a target program is created by combining one or more program components. And the operation of each program component that describes what operation each program component performs on the item that represents the operating state of the program, and for each operation of each program component, that operation is the item that represents the operating state of the program. An operation rule storage unit that describes what kind of state change is to be made, a connection relation input unit that inputs a connection relation between program components that make up a target program, and each program component in an order based on the connection relation. How the items that represent the operating state of the program change due to the sequential operation of Referring to create rule storage means, by verifying, characterized by comprising a verification means for detecting inconsistencies.

The detection of the contradiction includes, for example, the operation rule storing means including an operation rule describing the case where the operation of the program component causes the contradiction, and the verifying means refers to the operation rule to determine the operation state of the program. When the occurrence of a contradiction is detected by the operation rule when sequentially verifying the state change of the item shown, the contradiction is notified.

Further, there may be provided means for setting an initial state and a target state of an item representing the operating state of the program. In this case, the verification means sequentially verifies the state change of items representing the operating state of the program up to the final program part in the order based on the connection relationship, and determines whether the final state matches the target state. Alternatively, if they do not match, the occurrence of contradiction may be notified.

Further, there may be provided means for inputting a program part name for starting verification and a program part name for ending verification. It is also possible to obtain all the sequence sequences of the program components from the program component name for starting the verification to the program component name for ending the verification, and detect the inconsistency for each of the sequence sequences. The program component to be combined may be a source program, an object program, or an execution program (load module).

Further, according to the present invention, when a desired program is created by combining one or more program parts,
A program contradiction detection method for detecting contradictions, in which part operation information describing what kind of operation each program part performs with respect to the item indicating the operation state of the program, and the operation for each operation of each program part And a step of pre-storing an operation rule that describes what kind of state change will be caused to an item representing an operation state of the program and inputting a connection relation between program parts constituting a target program; , A step of inputting a program part name for starting the verification and a program part name for ending the verification, a step of setting an initial state and a target state of an item indicating an operating state of the program, and the verification based on the connection relationship. From the program part name to start to the program part name to end the verification, The step of obtaining the sequence of the RAM parts, and how the items indicating the operating state of the program change when the program parts sequentially operate in the order of the sequence, the part operation information and A step of detecting a contradiction by verifying with reference to the operation rule.

In this case, the detection of the contradiction includes, for example, an operation rule that describes the case where the operation of the program component causes the contradiction as the operation rule, and the state of the item indicating the operation state of the program is referred to with reference to the operation rule. When verifying changes sequentially, when a contradiction is detected by the operation rule, the contradiction is notified. Furthermore, the state change of the items representing the operating state of the program is sequentially verified up to the final program part in the order based on the connection relationship, and it is determined whether or not the final state matches the target state. Notify the occurrence.

[0012]

First, the connection relation between the program parts constituting the target program is input. Next, how each item representing the operating state of the program changes when each program component operates in the order based on the connection relationship is verified. At the time of verification, the component operation information and operation rules are referenced. The component operation information is information that describes the operation of each component, such as initializing a certain data item or inserting a physical medium in a certain device,
Operations such as are described. The operation rule consists of, for example, a condition part and an execution part. The condition part describes the current state and the executed action, and the execution part describes how to change the state when the condition part is true. Has been done.

At the time of verification, an operation rule in which the operation of each program part matches the condition part is activated, and the execution part of the rule is executed. If a contradiction is detected here, the fact is notified and the process ends. If not detected, the state of the input / output item is changed according to the execution part of the rule.

In the following, operation rules are applied to the operation of each program component in accordance with the order of connection relationships, and it is determined whether or not there is a contradiction. After the verification up to the last program component, it is determined whether or not the final state is the target state, and if it is not the target state, it is notified that a contradiction has occurred.
When no contradiction occurs in the application of the operation rule and the final state is the target state, the notification of no contradiction is given.

As described above, the program can be verified by using only the input / output relationship without going into details of the processing of each program component.

[0016]

Embodiments of the present invention will be described below with reference to the drawings.

FIG. 1 is a flow chart showing a processing procedure of a program contradiction detection method according to an embodiment of the present invention. FIG. 2 is a schematic diagram showing the configuration of the program contradiction detection apparatus of the embodiment that operates according to the procedure of FIG.

In FIG. 2, 10 is a display device, 20 is an input device, 30 is a computing device, 40 is a first storage device, and 70 is a storage device.
Is a second storage device. In the first storage device 40, a current state table 50, a target table 51, a verification start program name 52, a verification end program name 53, an operation rule group 54, a component operation data group 55, an execution path group 56, a current path 57, Areas for storing a currently executed program component 58, a connection relationship 59 between the program components, a correspondence table 60 between the program component name and the program module, and an execution result (hereinafter, referred to as a program execution result) 61 of the program component are secured respectively. ing. A program module is stored in the second storage device 70.

For convenience of explanation, both the storage area on the storage device and the data stored in the storage area are represented by the same number. For example, the number 50 represents an area for storing the current state table and also represents the current state table as data.

FIG. 3 is a diagram showing a connection relationship between program components when a program is created by combining the program components. Here, pi (i is an integer) represents a program component name, and rij (i, j is an integer) represents a connection relationship between pi and pj. The connection relation rij is the program component pi
Of the program component pi, it means that if the execution result of the program component pi is rij, the program component pj is executed next.

For example, if the execution result of the program component p2 in FIG. 3 is r23, the program component p3 is executed next, and if the execution result of the program component p2 is r24, the program component p4 is executed next. Such program component connection relation data is input by a user who wants to create a target program by combining program components according to the required specifications. The program component connection relation data is stored in the program component relation storage area 59 of the storage device 40.
Stored in.

FIG. 4 is a data group describing the operation of each program part (referred to as "part operation data").
Indicates the contents of. Here, the "motion" of a program part is
It refers to input / output of data and insertion / ejection of a physical medium (for example, a magnetic card) performed while the program component is being executed. For example, part name p1
(IFr12 THEN <Operation 12)
“>” Indicates that “if the result of executing the component p1 is r12, the component p1 executes <operation 12>”. In a specific example, in the case of a program component for inputting a personal identification number in the process of the automatic teller machine, if the execution result is "input completed", "input of personal identification number" is executed.

The component operation data group is stored in advance in the component operation data storage area 55 of the storage device 40.
The component operation data is described in the IF THEN format because when there are a plurality of component execution results (for example, normal termination and abnormal termination), the operation that caused the execution result is also different. .

FIG. 5 (a) shows the contents of a rule group (referred to as "motion rule group") relating to motion. The operation rule defines the influence on the state of the input / output item when a program component having a certain operation executes the operation. The operation rules are <operation name>, <condition part>, and <operation name>.
Execution unit>.

For example, if the operation of "input of data X" is executed in the state of "data X is" empty ", the state of data X changes from the state of" empty "to the state of" enter ". ], A description of “input of data X” is included in <action name> of the operation rule, a description of a state such as “data X is“ empty ”” is included in <condition part>, and <execution part>"Please turn on data X"
Enter the description about the state change. Here, X is a variable. The operation rule group is stored in advance in the operation rule group storage area 54 of the storage device 40.

Conditions to be detected as a contradiction are also described in the operation rule group. For example, in the above example, when the data X is already "ON" and the "input of data X" is tried again before referring to the data X (that is, the data X is already "ON"). If you want to detect "continuation" when you try to input "data X" on the above) because the operation is redundant, describe "data X is" ON "" in the <condition section> and execute "Partial contradiction" is described in part>.

FIG. 5B is a status table showing the status of various items. The state table includes a current state table and a target state table. The current state table is a table that stores the state at each point in time when each program component sequentially operates. The current state table is stored in the current state storage area 50 of the storage device 40.
The target state table is a table showing the target state after executing all program parts according to the connection relationship. The target state table is stored in the target state storage area 51 of the storage device 40.

Next, referring to the flow chart of FIG.
A general processing procedure for detecting a program contradiction of the present embodiment is described in (1) below, and an example in which the processing procedure is specifically applied to the detection of a contradiction in a payout processing program of an automated teller machine is described in (2) below. explain.

(1) General Processing Procedure In FIG. 1, the user first decides how to combine the program parts to create an intended program, and the connection relation (FIG. 3) is input from the input device 20. Input (step 100). The input connection relation is an area 5 for storing the connection relation between the program parts of the storage device 40.
9 is stored.

Next, the user inputs the verification start program part name (step 105) and the verification end program part name (step 110). These are respectively stored in the area 52 for storing the verification start program part name and the area 53 for storing the verification end program part name in the storage device 40. Further, the initial value of the current state table 50 is set (step 120), and the target state table 51 representing the target state after execution of the verification end program component is set (step 130).

Next, using the connection relation 59 between the program parts, all the execution paths from the verification start program name 52 to the verification end program name 53 are obtained and stored as an execution path group 56 (step 140). For example, in the example of the connection relationship shown in FIG.
2 is p1 and the verification end program part name 53 is p7, all the execution paths are calculated as {p1, r12, p2, r
23, p3, r36, p6, r67, p7}, {p1, r12,
p2, r23, p3, r37, p7}, {p1, r12, p
2, r24, p4, r45, p5, r57, p7}. In the execution path, program component names (p1, p2, etc.) and connection relationships (r12, r23, etc.) are arranged in order. Next, one path is selected from the obtained paths, and the current path 57 is set as the path to be verified (step 15).
0).

Next, the first program component name of the current path 57 is substituted into the currently executed program component name 58, and the second element (connection relation) of that path is substituted into the program execution result 61 (step 160). . Then, the operation rule corresponding to the operation of the currently executed program part name 58 and the program execution result 61 is applied and executed (step 170). Specifically, the currently executed program part name 58
For the component operation data of
The condition part of the part operation data is the program execution result 61.
The operation rule group 54 is searched for an operation rule matching with, and the execution unit is activated. The activation of the execution part of the operation rule means that the current state table 5 is based on the description of the execution part.
It is to update 0.

When the operation rule corresponding to the operation of the currently executed program part name 58 is applied and executed (step 170) and a contradiction occurs (step 180), the contradiction is notified (step 190). At this time, the current path 57 and the currently executed program part name 5 when the contradiction occurs
8 will also be notified.

If no contradiction occurs (step 18)
0), the currently executed program part name 58 and the verification end program part name 53 are compared (step 210), and if they do not match (step 220), the program part name to be executed next in the current path 57 is executed. It is set to the part name 58 and its execution result is the program execution result 61.
(Step 240). And step 17
It returns to 0 and continues verification.

If the currently executed program part name 58 and the verification end program part name 53 match (step 2
20) Since the last program component of the current path 57 has been verified, the current state table 50 and the target state table 51 are compared (step 230). If the two match (step 250), one path is selected from the remaining paths that have not been processed yet and set as the current path 57 (step 260).

If there is no remaining path and the current path 57 cannot be set in step 260 (step 270), the process is terminated. If there are remaining paths (step 2
70), the process proceeds to step 240, and it is similarly verified whether or not there is any contradiction in the remaining paths.

If the currently executed program name 58 and the verification end program part name 53 do not match (step 25
0) Since the state after execution up to the end program part of the path currently being verified was not the final target state, it is notified that a contradiction has occurred (step 190). After step 190, the process ends.

As described above, the program can be verified at the input / output operation level.

When the verification of the program is completed, the correspondence table 60 between the program component name and the program module
Using, the necessary program modules are read from the program module group 70 and linked to create a desired program.

(2) Case of Disbursement Processing of Automatic Cash Transaction Apparatus Next, an example of applying the present embodiment to the disbursement processing program of the automatic cash transaction apparatus to verify the contradiction of the program will be concretely described. Here, an expression similar to the predicate logic is used to express an action and a state, but another expression may be used. First, the case where there is no contradiction in the connection relation of the program parts input by the user in (a) and the case where there is a contradiction in the connection relation will be described in (b). (A) When there is no contradiction

FIG. 6 is a connection relation diagram (corresponding to FIG. 3) of the program parts of the payout processing. This connection relationship is input by the user and stored in the connection relationship storage area 59 of the program component of the storage device 40.

FIG. 7 is a part operation data group (corresponding to FIG. 4) of program parts used in the payout process. These data are stored in the component operation data storage area 55 of the storage device 40 in advance.

FIG. 8 shows a group of operation rules regarding input / output (corresponding to FIG. 5). Here, as input / output operations, three rules of data “input”, “output”, and “initialization”, and “insert”, “eject”, and “issue” of physical media are used.
Although an example of setting the four rules of “collection” and “collection” will be described, other rules may of course be used. Physical media include magnetic cards, statement slips, and cash.

In the operation rule of FIG. 8, "input (X)" refers to inputting a value to the data item X, "output (X)" refers to the value of the data item X, and "insert (X, “Y)” is to insert the physical medium Y into the device X from the outside, “Eject (X, Y)” is to eject the physical medium Y from the device X, and “Initialize (X)” is the data item X. The state of is ready for input ("empty"),
“Issue (X, Y)” is a state in which the physical medium Y can be generated or moved from the storage location in the device X and ejected (“ON”)
“Recovery (X, Y)” indicates that the physical medium Y is moved to the storage location in the device X and can be inserted (“empty”).

For example, the operation "input (X)" is
"IF data item (X) & status (X, data, empty)
THEN status change (X, data, input) ”,“ IF data item (X) & status (X, data, input) THEN
Conflict (input has not been referenced) "and" IF data item (X) & status (X, data, referenced) THEN status change (X, data, input) ".

"IF data item (X) & status (X, data, empty) THEN status change (X, data, input)"
Is a rule that if X is a data item and the data of X is "empty", change the data of X to "on". "IF data item (X) & status (X, data, input) THEN contradiction (input already unreferenced)" means that if X is a data item and the data of X is "input", the input data is inconsistent. Is a rule that occurs. "IF data item (X) & status (X, data, referenced) THEN status change (X, data, entered)" means that if X is a data item and the data of X is "referenced", The rule is to change the data of X to the state of "ON". The operation of "input (X)" is defined by the above rules.

Hereinafter, other operations are similarly defined. In addition, in FIG. 8, the term "object" means "physical medium".
That is.

FIG. 9A is a device table in which device names used in this embodiment are registered. Figure 9 (b)
Is a data item table in which data items used in this embodiment are registered. FIG. 9C is a physical medium table in which the physical medium used in this embodiment is registered. The device table, the data item table, and the physical medium table are stored in the first storage device 40.

The processing procedure will be described below with reference to the flowchart of FIG. First, the user inputs the connection relationship of the target payout processing program (step 100). Here, it is assumed that the connection relationship designed as shown in FIG. 6 is input.
Next, the user inputs the verification start program part name 52 (step 105). Here, “insert cash card” is the verification start program component 52. Next, the verification end program part name 53 is input (step 11).
0). Here, the “transaction completion greeting” is the verification end program 53.

Next, initial values are set in the current state table 50 (step 120). FIG. 9D shows the initial value of the current state table 50 of this embodiment. The state of each data item has three values of "empty", "on", and "referenced", and the initial values are all "empty". In addition, the state of the medium handled by each device shall be "empty" and "on",
The initial value is all "empty".

For example, "state (account number, data,
"Empty)" indicates that the "data" of the "account number" is "empty" (that is, no data is entered), and "state (card reader, cash card, empty)" is "cash of the card reader". "Card" indicates "empty" (that is, no cash card is inserted).

Further, a value is set in the target state table 51 representing the target state at the end of verification (step 130).
Here, the state of each data item is “on”, and the state of the physical medium handled by each device is “empty”. That is, when the payout process is completed, data is set in the data item such as the account number, and the device such as the card reader is in a state where the physical medium such as the cash card is discharged (empty state). .

Next, all execution paths reaching the verification end program part 53 from the verification start program part 52 are obtained and stored as an execution path group 56 (step 14).
0). Here, we will verify from "insert cash card" to "transaction completion greeting", {insert cash card, insert, PIN code input, input completion, payout amount input, input completion, content confirmation, confirmation press, processing ( Host communication), processing completion, cash card receipt, receipt completion, statement receipt, receipt completion, cash receipt, receipt completion, transaction completion greeting} are the only paths.

The above path is set as the current path 57 (step 150), the first program part name of the current path 57 is set in the currently executed program part name 58, and the first execution result of the current path is set in the program execution result 61 ( The second element of the current path) is set (step 160). Here, "cash card insertion" is the first program part name, and "insertion completed" is the first execution result.

At step 170, the operation rule corresponding to the part operation data of the currently executed program part name 58 is searched in the operation rule group 54 and applied. The process of step 170 is specifically as follows. First, the operation of the program component "insert cash card" differs depending on the execution result of the component. Here, since “insertion completed” is stored in the program execution result 61 as the execution result of the component “cash card insertion”, FIG.
In the operation data of the "Insert cash card" shown in, the value ("Insert (card reader, cash card)" and "Input (account number)" of the execution part of the rule whose condition part matches "Insert completed" is Suppose it was executed. Therefore, the operation rule group 54 (FIG. 8) is searched for an operation rule corresponding to these operations, and the execution unit whose condition part is true is executed. “Input (account number)” here means reading the account number from the cash card.

First, a rule whose pattern matches "insertion (card reader, cash card)" is searched. Then, since it matches the operation rule of "insert (X, Y)" in FIG. 8, "card reader" is substituted for X and "cash card" is substituted for Y. Here, X and Y are variables, and can be matched with arbitrary constants (here, "card reader" and "cash card"). As a result, the first condition part of the insertion (X, Y) becomes "device (card reader) & physical medium (cash card) & status (card reader, cash card, empty)".

Next, each item of the above condition section, device table (FIG. 9A), and data item table (FIG. 9).
(B)), the physical medium table (FIG. 9 (c)), and the current state table (FIG. 9 (d)) are compared with each other. As a result, "device (card reader) & physical medium (cash card) &
Since the "state (card reader, cash card, empty)" becomes true, "state change (card reader, cash card, on)", which is the execution unit corresponding to it, is executed. As a result, the current state table 50 of FIG. 9D changes from "state (card reader, cash card, empty)" to "state (card reader, cash card, on)". If the first condition part is false, the same is done for the second condition part. If all the conditional parts are examined and there is no conditional part that is true, it means that a contradiction has occurred.

Similarly, for "input (account number)" which is another operation of "insert cash card", the operation rule is searched in the operation rule group 54 and applied. As a result, the current state table 50 changes from “state (account number, data, empty)” to “state (account number, data, on)”.

In this way, when the operation rule is applied to the currently executed program part 58 and no contradiction occurs (step 180), the currently executed program part name 58 (cash card insertion) and the verification end program part name 53 (transaction). Completion greetings) are compared (step 210). Since the two do not match, the name of the program component to be executed next is selected from the current path 57 and set in the currently executed program component name 58 (step 240). Here, "password input" is set. Then, the process returns to step 170.

In this embodiment, even if the program parts are sequentially executed, no contradiction occurs. Therefore, the above processing is repeated until the currently executed program part name 58 matches the verification end program part name 53. Will be done. FIG. 10 shows the state change when the operation rules are sequentially executed.
Shown in.

The programs are sequentially executed, and the currently executed program part name 58 and the verification end program part name 53
If the two match (step 220), the current state table 5
0 and the target state table 51 are compared (step 23
0). The final state of FIG. 10 matches the values of the target state table 51 set in step 130 (all data items are “on”, and the physical medium handled by the device is “empty”) (step 250), so the verification start program Part name 5
From the paths from 2 to the verification end program part name 53, select one path that has not been verified yet, and select the current path 57.
(Step 260). In this embodiment, since there is only one path, there are no remaining paths (step 270).
Therefore, the process ends without any contradiction being detected.

As described above, the program could be verified at the input / output operation level from "insert cash card" to "transaction completion greeting".

When the verification of the program is completed, the correspondence table 60 between the program part name and the program module
Using, the necessary program modules 70 are linked to create a target program.

(B) When a contradiction occurs (when "cash card insertion" is not inserted) Next, the user designs the connection relationship without inserting the program part "cash card insertion", and therefore the contradiction does not occur. The case where it occurs will be described.

FIG. 11 shows a connection relationship diagram of program parts designed and input by the user. The verification start program part name, the verification end program part name, the initial value of the current state table, the value of the target state table, the device table, the physical medium table, the data item table, the operation data, and the operation rule are the same as those in the above embodiment (2) ( It is the same as when there is no contradiction in a).

The processing procedure will be described below with reference to FIG.
However, since the details of the processing procedure are the same as those in the above-described embodiment (2) (a), only the differences from (2) (a) will be described focusing on the state change. FIG. 12 shows a state change when the program component is executed according to the connection relation diagram of the program component in FIG.

(2) Unlike (a), since there is no "insert cash card", the status of the cash card and account number remains "empty", and when the currently executed program component is "processing", The state is the fourth state in FIG. 12 (the state after the execution of “confirm contents”). In this state, the operation of the program component “processing” is executed.

When a rule matching the pattern with "output (account number)" which is the operation when the execution result of the program part "processing" is "processing completed" is searched from FIG. 8, "output (X)" is searched. X is an "account number" because it matches the operation rule ". The first condition part of "output (X)" is "IF data item (X) & status (X, data, empty)", but "data item (account number)" is true and From the state of "state (account number, data,
Sky) "is also true. Therefore, since "data item (X) & status (X, data, empty)" is true, the contradiction (not input) which is the execution unit is executed (step 170). Since a contradiction has occurred (step 180), the contradiction is notified (step 190).

As described above, when the user tries to refer to the data without inputting the data, the contradiction is detected and notified, so that the programmer can know the omission of the program part.

(C) When a contradiction occurs (when "cash card receipt" is not entered) Next, the user designs the connection relationship without including the program part called "cash card receipt", which causes a contradiction. The case where it occurs will be described.

FIG. 13 shows a connection relation diagram of program parts designed and input by the user. The verification start program part name, the verification end program part name, the initial value of the current state table, the value of the target state table, the device table, the physical medium table, the data item table, the operation data, and the operation rule are the same as those in the above embodiment (2) ( It is the same as when there is no contradiction in a).

The processing procedure will be described below with reference to FIG.
However, since the details of the processing procedure are the same as those in the above-mentioned embodiment (2) (a), only the differences from (2) (a) will be described, centering on the state change. FIG. 14 shows a state change when the program component is executed according to the program component connection relationship diagram of FIG.

(2) Unlike (a), since there is no "receipt of cash card", the status of the cash card is "on" when the currently executed program component is "transaction completion greeting".
It remains as it is. Even if the operation of the program part called "transaction completion greeting" is executed here, since there is no operation, the state does not change. When the currently executed program name 58 and the verification end program name 53 match (step 220), the current state table 50 and the target state table 51 are compared (step 230). Here, in the current state table 50, the state of the cash card is "on", but in the target state table 51, the cash card is "empty", so they do not match (step 250). Therefore, the contradiction is detected, and the occurrence of the contradiction is notified (step 19).
0).

As described above, when the card is inserted, but the transaction is ended without returning it, the contradiction is detected and notified, so that the programmer can know the omission of the program part. In addition, although the payout process of the automatic teller machine has been described as an example in the above embodiment, the present invention can naturally be applied to the creation of another process program.

In the processing procedure of FIG. 1 described above, all the execution paths are first obtained, and then the consistency is verified for all the paths. However, it is also possible to verify the consistency of the paths while obtaining the execution paths. . Hereinafter, such an embodiment will be described.

FIG. 15 is a flowchart showing the processing procedure of the embodiment for verifying the consistency of the path while obtaining the execution path. FIG. 16 is a schematic diagram showing the configuration of a program contradiction detection device that operates according to the processing procedure of FIG. The configuration of FIG. 16 is the same as that of FIG. 2, but the execution path group 56, the current path 57, and the current execution program part 58 in FIG. 2 are deleted, and instead, the state trace pair list 62 is used.
Has been added. FIG. 17 is a transition diagram of the state trace pair list when the program detection process is performed according to the procedure of FIG. What is the state trace pair list?
A trace (trace) of starting the state table and the program shown in FIG. 5B in accordance with the connection relation, {p
It is represented by a program sequence such as 0, p1, p2, ..., Pn}.

The processing procedure will be described below with reference to FIG. Steps 500 to 540 are shown in FIG.
Steps 100 to 130 are the same. In the present embodiment, for the sake of explanation, it is assumed that FIG. 3 is input in step 500, p1 is input as the verification start program name in step 510, and p7 is input as the verification end program name in step 520. An initial value is given in step 530, which will be generically referred to as S0. Further, the target state table input in step 540 will be referred to as Sf.

Next, from the initial value S0 currently stored in the state table 50 and the value p1 stored in the verification start program name 52, the state trace list (S0, {p
1}) is created and added to the state trace pair list 62 (step 550). State trace pair list 6
When the last program part name of the trace in 2 is extracted, p1 is obtained (step 560). The execution result of p1 is obtained from the connection relation 59, and the corresponding operation rule is applied (step 570). At this time, if a contradiction occurs (step 580), the user is notified of the contradiction (step 640), and the process ends.

If no contradiction occurs, a new state trace pair list ((S11, S11) is obtained from the new state {S11} obtained as a result of applying the operation rule and the next execution program name {p2} obtained from the connection relation 59. {P1, p
2})) is created and the previous state trace pair list 62 is deleted (step 590). The trace of the newly generated state trace pair list 62 is searched for a value including the value p7 of the verification end program part name 53 (step 600), and if not, the process proceeds to step 560. If yes, p7, which is the value of the verification end program part name
For all state trace pairs including, the state is compared with the value in the target state table 51 and compared (step 6
10) If all match, delete the matching state trace pair from the state trace pair list 62 (step 620) and check if the state trace pair list is not empty (step 630). If it is empty, it is determined that all execution paths from p1 to p7 are consistent, and the processing ends. If there is a mismatch, the user is notified of the contradiction (step 640) and the process ends.

As described above, the consistency of the program can be verified by paying attention only to the input / output relationship.

[0081]

As described above, according to the present invention,
Since errors in processing procedures and omissions in processing at the application level are automatically detected, the burden on the programmer is reduced and productivity is increased. In particular, it is suitable to be applied to a case where a target program is created by combining screen-based program components.

[Brief description of drawings]

FIG. 1 is a flowchart showing a processing procedure of a program contradiction detection method according to an embodiment of the present invention.

FIG. 2 is a schematic diagram showing the configuration of a program contradiction detection device of this embodiment.

FIG. 3 is a diagram showing an example of a general connection relationship between program parts.

FIG. 4 is a diagram showing an example of general operation description data of a program part.

FIG. 5 is a diagram showing a general description example of operation rules and a general description example of a state table.

FIG. 6 is a diagram showing a normal connection relationship of program parts for payout processing.

FIG. 7 is a diagram showing operation data of program parts used in payout processing.

FIG. 8 is a diagram showing operation rules regarding input / output.

FIG. 9 is a diagram showing a device table, a data item table, a physical medium table, and a status table used in a payout process.

FIG. 10 is a transition diagram of a normal payout processing state table.

FIG. 11 is a connection relation diagram of program parts for abnormal payout processing.

FIG. 12 is a transition diagram of a state table of abnormal payout processing.

FIG. 13 is a connection relation diagram of program parts for abnormal payout processing.

FIG. 14 is a transition diagram of a state table of abnormal payout processing.

FIG. 15 is a flowchart showing another processing procedure of the program contradiction detection method.

FIG. 16 is another configuration diagram of the present embodiment.

FIG. 17 is a transition diagram of the status trace pair list.

[Explanation of symbols]

10 ... Display device, 20 ... Input device, 30 ... Arithmetic device, 4
0 ... Storage device, 50 ... Present state table, 51 ... Target state table, 52 ... Verification start program part name, 53 ...
Verification end program part name, 54 ... Operation rule group, 55
... parts operation data group, 56 ... execution path group, 57 ... current path group, 58 ... currently executed program part name, 59 ... program part connection relationship, 60 ... program part name / program module correspondence table, 70 ... program module group.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Masayuki Saito 7-1, 1-1 Higashi Narashino, Narashino, Chiba Prefecture Hitachi Keiyo Engineering Co., Ltd. (72) Inventor Hiroyuki Takagi 7-1, 1-1 Higashi Narashino, Narashino, Chiba Hitachi Keiyo Engineering Co., Ltd. (72) Inventor Hirofumi Kondo 890 Kashimada, Sachi-ku, Kawasaki-shi, Kanagawa Hitachi System Plaza Shin-Kawasaki Hitachi Systems Development Laboratory

Claims (10)

[Claims] 1. A program contradiction detection device for detecting a contradiction when a target program is created by combining one or more program parts, wherein each program part corresponds to an item indicating an operating state of the program. The component operation storage means that stores the component operation information that describes whether to perform such an operation, and for each operation of each program component, what state change the operation causes for the item that represents the operation state of the program. An operation rule storage unit that stores the described operation rule, a connection relation input unit that inputs a connection relation between program components that make up a target program, and each program component sequentially operates in an order based on the connection relation. How to change the state of the item that indicates the operating state of the program by A program contradiction detection device comprising: a verification unit that detects a contradiction by performing verification by referring to a rule. 2. The operation rule storage means includes an operation rule describing a case where an operation of a program component causes a contradiction, and the verification means includes an item indicating an operation state of a program with reference to the operation rule. The program contradiction detection device according to claim 1, wherein when the contradiction is detected by the operation rule when sequentially verifying the state change, the contradiction is notified. 3. The program contradiction detection device according to claim 1, further comprising means for setting an initial state and a target state of an item representing an operating state of the program. 4. The verification means sequentially verifies the state change of items representing the operating state of the program up to the final program part in the order based on the connection relation, and determines whether the final state matches the target state. The program contradiction detection device according to claim 3, wherein the program contradiction detection device makes a determination and notifies the occurrence of a contradiction when they do not match. 5. The program contradiction detection device according to claim 1, further comprising means for inputting a program part name for starting verification and a program part name for ending verification. 6. Further, all the sequence of program parts from the program part name for starting the verification to the program part name for ending the verification are obtained, and the verifying means sets each program according to each sequence. 6. The program contradiction detection device according to claim 1, wherein the contradiction is detected by verifying a state change when the parts are sequentially operated. 7. The program contradiction detection device according to claim 1, wherein the program component is a source program, an object program, or an execution program. 8. A program contradiction detection method for detecting a contradiction when a target program is created by combining one or more program parts, wherein each program part is associated with an item indicating an operating state of the program. The component operation information describing whether to perform such an operation, and the operation rule describing for each operation of each program component what kind of state change the operation represents for the item indicating the operating state of the program, in advance. The step of inputting the connection relationship between the program parts that make up the target program and storing it, the step of entering the program part name to start the verification and the program part name to end the verification, and the operating state of the program A step of setting an initial state and a target state of an item representing A step of obtaining a sequence of program parts from a program part name to start verification to a program part name to end the verification, and the operation of the program when each program part sequentially operates in the order of the sequence. Program inconsistency detection, characterized in that it comprises a step of detecting an inconsistency by verifying how the item representing the state changes with reference to the component operation information and operation rule. Method. 9. The operation rule includes an operation rule describing a case where an operation of a program component causes a contradiction, and the step of detecting the contradiction by the verification checks the operation state of the program while referring to the operation rule. 9. The program contradiction detection method according to claim 8, wherein when the occurrence of a contradiction is detected by the operation rule when sequentially verifying the state change of the item indicated, the contradiction is notified. 10. The step of detecting a contradiction by the verification sequentially verifies the state change of items representing the operating state of the program up to the final program part in the order based on the connection relation, and the final state matches the target state. The program contradiction detection method according to claim 8 or 9, wherein it is determined whether or not to perform, and when the two do not match, the contradiction is notified.