JPH06230949A - Automatic program generating device - Google Patents

Abstract

PURPOSE:To provide an excellent automatic program generating device which can reuse the specifications of even an unchanged unit for the change of a component unit of a controlled system and also can perform the compact and clear description of specifications for a large number of units. CONSTITUTION:A unit original specification input part 1 supplies the specifications for each unit as a state transition model. An out-unit specification input part 3 and a total correlation specification input part 4 supply the correlation specifications as a state transition model to show the correlation between the units. A specification storing part 5 stores mutually and individually those specifications. Then an intermediate source code generating part 8 and an intermediate source code link part 10 generate the programs based on the specifications.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an improvement of a program automatic generation device for generating a software program based on the software specifications represented by a state transition model.

[0002]

2. Description of the Related Art Software for controlling a system such as hardware and software is generally called control software. Among these, examples of control software for controlling hardware include a control program for an automatic teller machine (cash dispenser) and a machine tool. A so-called operating system (OS) can be considered as an example of control software that controls the software itself.

As an apparatus suitable for developing such control software, an automatic program generating apparatus for generating a program based on a software state transition model specification has been known. Here, the state transition model is one of the model formats for expressing the specifications of software, and grasps the software or controlled system as an entity that transits to multiple “states” and , Is expressed by a transition between the states. Further, the state transition model specification is a specification of software described by such a state transition model.

In principle, this state transition model is used not only for control software but also for database applications such as application software for specific purposes.
It can also be used to represent software. However, the state transition model is particularly suitable for specification representation of control software that controls hardware. That is, the state transition model describes software and its controlled system as
It is expressed by the "state", the "transition" between the states, the "event" that causes this transition, and the "action" that occurs at the time of the transition. In other words, the state transition model transitions the software or its controlled system by accepting the new input (event) at the present in the “state” formed by the past input,
It means to express as performing an output (action) according to the event in the “state” at the time of transition. On the other hand, the hardware control software accepts a new current “input” in the “state” of the hardware formed by past inputs from the sensor or switch, and responds to the current input in the state. It issues a hardware control command. As described above, since the state transition model originally has a common configuration with the control software, it is suitable for describing the control software.

Further, since the state transition model is a so-called formal description method whose contents are specifically specified, it is possible to automatically generate a program based on the state transition model specification. The automatic program generator described above is based on these facts and is particularly suitable for automatic program generation of control software.

The program mentioned here means software expressed in the form of a certain programming language, and typically, a source code that can be translated into a machine language by a compiler or sequential execution by an interpreter. It is possible to understand, including a so-called object program translated into a machine language.

In the software state transition model, the system to be controlled is defined by the combination of the states of each of the plurality of units constituting the system. The units that make up the system, which is hardware, are mainly hardware, but software and
The units constituting the system include each job in the multitask system and software elements such as an access control unit included in the OS.

The expression of the controlled system by a plurality of "states" is performed as follows. For example, in a system in which the controlled system is composed of two hardware units, a unit A and a unit B, A
If there are 2 types of states and unit B can have 3 types of states,
The state of the entire system is as follows: Unit A, Unit B
There is a possibility of transitioning to 6 types of states by the combination of states, that is, 2 × 3 = 6. Therefore, in the state transition model specification of the control software of this system, a state that can actually occur is selected from the six types of states, and appropriate transitions, events and actions are added between them.

[0009]

(1) By the way, in a controlled system, a system configuration is changed due to a function improvement, a man-machine interface improvement, or the like, and units are added / changed / removed. In this case, it is generally referred to as "change" in). Then, when such a system configuration is changed, it is necessary to change the control software accordingly.

For example, a new unit C is added to the system including the units A and B, and the unit C
If two states are possible, the transitionable state of the system including the unit C is 2 × 3 × 2 = 12, and 12
The number will be doubled. Moreover, since the definitions of the 12 types of states include the unit C, they are all different from the 6 types of states before the addition of the unit C. In the conventional program automatic generation device, the entire state transition model specification is treated as an integral part. Therefore, in the conventional program automatic generation device, when such a change is made, the software specification after the addition of the unit C has to be rewritten completely independently of that before the addition.

In particular, in such a case, the specifications of the individual units that have not changed are usually little or not changed at all. Nevertheless, in the conventional program automatic generation device, as described above, the specification of the entire software needs to be completely rewritten, so that the specification of the part related to the unit that has not been changed cannot be reused.
Therefore, it is difficult to improve the production efficiency of the program.

(2) Further, in the conventional automatic program generation device, the state of the controlled system is defined by the combination of the states of all units constituting the system. For this reason, when the number of units that make up the system is large, the number of states for describing the specifications is an enormous number, which is close to the number of possible combinations of states of individual units. For this reason, in the conventional program automatic generation device, the description amount of the entire specification increases and the description content becomes complicated, and it is difficult to describe and read the specification.

The present invention was proposed in order to solve the problems of the prior art as described above, and its purpose is to make a unit that does not change even when the unit constituting the controlled system is changed. An object of the present invention is to provide an excellent program automatic generation device capable of reusing the specification regarding. Another object of the present invention is to enable compact and simple specification even when the number of units is large.
An object is to provide an excellent automatic program generation device.

[0014]

To achieve the above object, an automatic program generation device of the present invention is a program automatic generation device for generating a software program relating to a system composed of units based on the specifications of the software. In, unit unique specification input means for inputting the specifications for each unit in a state transition model, correlation specification input means for inputting correlation specifications representing the correlation between the units in a state transition model, and unit unique specifications It has a unit unique specification saving means for saving, a correlation specification saving means for saving the correlation specification, a program creating means for creating the program based on each of the specifications, and an output means for outputting the created program. It is characterized by

[0015]

The present invention having the above structure has the following functions. That is, in the present invention, the specification unique to each unit is input as the unit unique specification from the unit unique specification input means and stored in the unit unique specification storage means. On the other hand, the correlation specification between each unit is input as the correlation specification from the correlation specification input means and stored in the correlation specification storage means. Then, the automatic generation of the program is performed by the program generation means based on the above-mentioned specifications.

As described above, according to the present invention, the correlation specifications between units are handled separately from the unit-specific specifications unique to each unit. Therefore, in principle, only the correlation specifications need to be changed when the unit is changed. Unit specifications that are sufficient or unchanged can be reused.

Further, in the present invention, the correlation specifications between units are handled separately from the unit-specific specifications unique to each unit. Therefore, the specifications of the entire controlled system are the states of the entire system and the transitions between these states. Can be expressed only by the operation of the unit related to. Therefore, it is not necessary to define the states of all the units that configure the system for each state of the entire system, and compact and simple specification description is possible even when the number of units is large.

[0018]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An automatic program generation device (hereinafter referred to as "this device") which is an embodiment of the present invention will be specifically described below with reference to the drawings. It should be noted that this device is realized on a computer, and each function of this device is realized by operating the computer in a predetermined procedure expressed in the form of a program. Therefore, the present apparatus will be described below assuming a virtual circuit block having each function of the apparatus.

(1) Configuration of the embodiment ... FIG. 1 This device generates a source code for compilation based on the state transition model specification. FIG. 1 is a configuration diagram of this device. As shown in FIG. 1, the present apparatus includes an input device 1 such as a keyboard and a unit unique specification input unit 2 for describing and inputting a unit unique specification unique to each unit constituting a controlled system by a state transition model. And have. In addition, the present apparatus includes a unit-external-specification input unit 3 for describing and inputting a unit external-specification indicating a relationship between each unit and the outside of the unit with a state transition model, and a correlation between the units as viewed from the entire system. An overall correlation specification input unit 4 for describing and inputting an overall correlation specification, which is expressed based on the unit external specifications, by a state transition model.
And have.

The unit external specifications and the overall correlation specifications correspond to the correlation specifications. Further, the unit unique specification input section 2 constitutes the unit unique specification input means together with the input device 1. Further, the unit external specification input unit 3 and the overall correlation specification input unit 4 are the input device 1
Together with this, the correlation specification input means is configured.

Further, the present apparatus is provided with the unit unique specification,
A specification storage unit 5 for separately storing the unit external specifications and the overall correlation specifications (having a role as both the unit unique specification storage means and the correlation specification storage means)
have. The apparatus also includes a comparison table input unit 6 for inputting a comparison table of the elements included in each of the specifications and expressions on the source code corresponding to each element, and a comparison table storage unit for storing the comparison table. 7 and 7. Further, the apparatus has an intermediate source code generation unit 8 for converting into an intermediate source code for each unit specification and for each overall correlation specification based on the specifications and the comparison table.

The apparatus also includes an intermediate source code storage unit 9 for storing a plurality of intermediate source codes generated by the intermediate source code generation unit 8 and a plurality of intermediate sources stored in the intermediate source code storage unit 9. An intermediate source code link unit 10 that links source codes to generate a final source code. The apparatus also has a final source code storage unit 11 that stores the final source code generated by the intermediate source code link unit 10.
The intermediate source code generating unit 8 and the intermediate source code linking unit 10 constitute the program generating means. The final source code storage unit 11 has a mechanism for outputting the final source code to the outside.
It corresponds to the program output means. In addition, this device
Although not shown, it is provided with necessary I / O control circuits and display devices.

(2) Operation of the embodiment ... FIGS. 2 to 10 Next, the automatic program generation in the present embodiment having the above-mentioned configuration will be described with reference to an actual example. This example is a part of control software that controls an automatic teller machine system used in a financial institution such as a bank.
It controls the card unit and the password unit that make up this system.

[Input of Information] In the automatic program generation in this embodiment, the user first inputs the unit-specific specifications by the state transition model for each unit constituting the controlled system. Here, FIG. 2 is an example of a unit unique specification relating to the card unit of the above-mentioned example, and represents an operation of taking in a card, reading a magnetic tape of the card, and setting at a printing position. Further, FIG. 3 is an example of a unit unique specification relating to the above-described personal identification unit, and represents an operation of receiving an input of a personal identification and checking it. In these state transition model specifications, transitions between states represented by circles are represented by arrows, and each transition has an event and an action related to the transition.
It is written separated by "/" (slash).

Further, the user defines the correlation between the card unit and the personal identification unit by inputting the unit external specification and the overall correlation specification. That is, in the present embodiment, the correlation between each unit is described by two stages of the unit external specification and the overall correlation specification. Here, the unit-to-outside specification represents the relationship between the unit and the outside of the unit for each unit. Specifically, among the transitions of the unit-specific specifications, those specific to the outside of the unit are specified. Entered by subscribing to an event or action named. In addition, the overall correlation specification expresses the correlation between each unit viewed from the entire system. Specifically, for each transition of the entire system, the event from the unit that causes that transition and the transition The action for the unit that occurs at that time is described by the same name as used in the unit external specification.

For example, in the cash payout operation in the system of the above-mentioned example, it is assumed that the operator inputs the personal identification number in parallel with the operation of taking in the card and reading the personal identification number from the magnetic tape of the card. Then, when collating the personal identification number read from the card with the personal identification number input by the operator thereafter, there is a limitation that the collation of the personal identification number cannot be started until the reading from the card is completed. Since this restriction is a correlation between the card unit and the secret code unit, this correlation is entered as follows.

First, the unit external specifications are added to the unique specifications of each unit. FIG. 4 is an example in which a unit external specification is added to the unit unique specification of the card unit,
Further, FIG. 5 is an example in which the unit external specifications are added to the unit unique specifications of the personal identification unit. It should be noted that in these drawings, the portion of the external specifications of the unit is represented by shading. That is, in FIG. 4, at the time of the transition “magnetic tape reading completed”, the action “card preparation OK” for notifying the outside that the reading of the magnetic tape is completed is added. Further, in FIG. 5, “check start” is weighted as the event that causes the transition “input completion”.
These unit-to-outside specifications are for controlling so that the personal identification unit cannot proceed to the state "checking" until the card unit proceeds to the state "setting in the printing position". Then, the user implements such control between the card unit and the personal identification unit by describing and inputting the overall correlation (interaction) specifications as shown in FIG.

That is, according to the overall correlation specification of FIG. 6, the state "card preparing" of the entire system transits to "password checking" on condition of the event "card preparation OK", and at the time of this transition, the action "checking" is performed. It means that "start" is issued. That is, the above-mentioned action "card preparation OK" and event "check start" are means for information communication between the unit-specific specifications and the overall correlation specifications.

Since the action issued at the time of transition becomes an event on the receiving side, in other words, the overall correlation specification of FIG. 6 means the following. In other words, the entire system is initially in the "card preparation" state, and when the action "card preparation OK" is sent to notify that the system has proceeded from the card unit to the state "setting in the printing position", the secret code unit is notified. On the other hand, the event "Check start" is issued to inform the user that he / she can proceed to "Checking". The specifications as described above are stored in the specification storage unit 5.

Further, the user inputs a comparison table used for converting the state transition model specification into the source code. Here, FIG. 7 is a comparison table in the above-described example, and is described by the correspondence between the events and actions in the specifications and the expressions in the source code. In this comparison table, correspondence relationships are described for all events and actions except for the information communication means between the unit-specific specifications and the overall correlation specifications described above. This reference table is stored in the reference table storage unit 7.

[Generation of Program] After inputting the above information, the intermediate source code generation unit 8 generates an intermediate source code based on the information, and the intermediate source code storage unit 9 stores the generated intermediate source code. It should be noted that such source code is generated by classifying unique character string data such as state names included in the data of each specification according to the type, order, and mutual relation, and formulating such as command words of the programming language. It can be realized by outputting in a predetermined order together with the sentence. Here, FIG. 8 and FIG. 9 are examples of the intermediate source code according to the above-mentioned example, FIG. 8 corresponds to the unit unique specification and unit external specification, and FIG. 9 corresponds to the overall correlation (interaction) specification. Is. In this intermediate source code, the expressions of specifications are used as they are for “card preparation OK” and “start check”, and are not converted into source code.

Finally, the intermediate source code link section 10
However, these "card preparation OK" and "check start"
Unique data names are assigned to the two, and the final source code converted to them is generated. For example, the data names communicate1 and communicate2 are assigned to the specification expressions "card preparation OK" and "check start", respectively. Then, as shown in FIG. 10, the expressions “card preparation OK” and “check start” are converted into expressions on the source code, and the state becomes compilable. That is, the unit specifications and the overall correlation specifications are linked in the source code.

(3) Effects of the Embodiment As described above, according to this embodiment, the unit-specific specifications for each unit, and the unit external specification and the overall correlation specification indicating the correlation between the units are handled separately. ,
Even if the units that make up the controlled system are changed, the specifications relating to the unchanged units can be reused, so that it is not necessary to completely rewrite the specifications of the entire system, and the software production efficiency is improved.
For example, when a new unit (for example, a transfer ticket unit) is added to the above-mentioned example, and there is no change in the original operation of the card unit and the personal identification unit, the specifications of FIGS. It is possible to use. Also, when a unit that affects another unit is changed, it is necessary to change the unit external specifications of the affected unit, but the unit-specific specifications can be reused as they are.

Further, according to this embodiment, the state of the controlled system is defined as being different from the state of each unit according to the overall correlation specification. Therefore, even when the number of units constituting the system is large, The number of states to describe a specification is far smaller than the number of possible combinations of states of individual units. For this reason, the description amount of the entire specification is reduced, the size is made compact, and the description content is simple, and the description and reading of the specification are easy.

For example, it is assumed that there are five units, A, B, C, D, and E, and each of them can have three states. At this time, according to the conventional specifications, the state of the entire system also needs to be described as a combination of the states of the units, so the number of states described in the specification for the entire system is 3
From × 3 × 3 × 3 × 3 = 243, it was about 243. However, even in such a case, according to the present embodiment, since it can be expressed by the unit unique specification or the overall correlation specification of each unit, if the number of states appearing in the overall correlation specification is k, then 3 + 3 + 3 + 3 + 3 + k = 15 + k The total number of states for each system and the entire system will remain at 15 + k. Thus, 243-15 = 228
Therefore, the number of states appearing in the overall correlation specification is 200
Unless the system exceeds the limit, the total number of states required to describe the specifications of each unit and the entire system is considerably small, and the description and reading of the specifications are easy.

(4) Other Embodiments The present invention is not limited to the above embodiments,
The following other examples are also included. For example, the format of the specifications shown in the above embodiments is an example of the state transition model specifications, and the state transition model specifications of other formats can be freely used, such as representing a node representing a state with a rectangle. Similarly, the source code shown in the above embodiment is only an example of the source code, and which language is used as the source code is arbitrary. Further, in generating a program, not only the source code but also an object program module in machine language may be generated. Further, the input of the comparison table may be omitted, and the program generation means may assign an appropriate source code expression to each event name or action name. Further, although the automatic program generation device of the above-described embodiment is realized on a computer, all or part of the functions thereof may be realized on a dedicated electronic circuit.

[0037]

As described above, according to the present invention, it is possible to provide an excellent program automatic generation device capable of reusing the specifications relating to a unit that has not been changed, even when the unit constituting the controlled system is changed. Therefore, the production efficiency of software is improved. Further, according to the present invention, it is possible to provide an excellent program automatic generation device capable of compact and simple specification description even when the number of units is large, and therefore even when the number of units is increased. , It becomes easy to describe and read the specifications.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a program automatic generation device according to an embodiment of the present invention.

FIG. 2 is an example of a unit unique specification (card unit) in the embodiment of the invention.

FIG. 3 is an example of a unit unique specification in the embodiment of the present invention (password unit).

FIG. 4 is a diagram (card unit) showing the contents in which the unit external specification is added to the unit unique specification of the example in the embodiment of the present invention.

FIG. 5 is a diagram showing the contents of adding the unit external specifications to the unit unique specifications of the actual example in the embodiment of the present invention (password unit).

FIG. 6 shows an example of overall correlation specifications in the embodiment of the present invention.

FIG. 7 is an example of a comparison table according to an embodiment of the present invention.

FIG. 8 is an example of an intermediate source code according to an embodiment of the present invention (corresponding to specifications for each unit).

FIG. 9 is an example of an intermediate source code according to an embodiment of the present invention (corresponding to the overall correlation specification).

FIG. 10 is an example of final source code according to an embodiment of the present invention.

[Explanation of symbols]

 1: Input device 2: Unit unique specification input unit 3: Unit external specification input unit 4: Overall correlation specification input unit 5: Specification storage unit 6: Control table input unit 7: Control table storage unit 8: Intermediate source code generation unit 9 : Intermediate source code storage unit 10: Intermediate source code link unit 11: Final source code storage unit

Claims (1)

[Claims] 1. A program automatic generation apparatus for generating a software program relating to a system composed of units based on the specifications of the software, unit unique specification input means for inputting the specifications of each unit by a state transition model. A correlation specification input means for inputting a correlation specification representing a correlation between the units in a state transition model, a unit unique specification saving means for saving the unit unique specification, and a correlation specification saving means for saving the correlation specification. An automatic program generation device comprising: a program generation unit that generates the program based on each of the specifications; and an output unit that outputs the generated program.