JP2016201009A - Source code generation system, source code generation apparatus, source code generation method, and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To automatically generate all source codes representing exception handling which occurs during operation.SOLUTION: A source code generation system includes: a processing item list storage unit 1071 which stores a processing item list 107; a behavior description information storage unit 1081 which stores behavior description information 108; a behavior description generation unit 501 which generates a source code defining a class; an operation generation unit 502 which generates a source code defining an operation; an exception description generation unit 503 which generates a source code representing exception handling which occurs during the operation; a condition description generation unit 504 which generates a source code representing conditional branching of the operation; and a processing description generation unit 505 which generates a source code representing processing content of the operation.SELECTED DRAWING: Figure 1

Description

  The present invention relates to a source code generation system, a source code generation device, a source code generation method, and a program.

  In UML (Unified Modeling Language), which is a typical model description language, there are a class diagram as a static model, a state transition diagram, a sequence diagram, and an activity diagram as a dynamic model. The standard specifies only the model elements used in individual diagrams, that is, how to write class boxes and states, and how to write conditions. The contents to be described and the consistency between diagrams are left to the designer. ing.

In an embedded product, software exception handling corresponding to an “exception” event such as a failure or abnormality occurring on a hardware device such as a sensor or a display is important, but a description method in UML has not been determined.
In use case analysis, a use case diagram may be described as one of the scenarios in the use case description. However, because use case diagrams are unformatted text at the required level, code generation requires linkage with design information at the detailed design level and creation of code generation. It depends.

  In addition, it is necessary to perform execution control according to the "processing priority" corresponding to the interrupt during function execution. Generally, when competing relations are organized in units of tasks by task conflict analysis There is. The task is data at the software design level, and it is necessary to link with the design information at the detailed design level and to create a code as in the exception processing.

In Patent Document 1, exception processing can be defined and automatically embedded in the source code.
Further, in Patent Document 2, it is possible to execute the source code based on the execution priority information by entering the priority for each hierarchical function item.

JP 2007-094922 A JP 2012-252555 A

  In Patent Document 1, a state transition diagram can be used as an input to output one conditional branch statement in the case of a state other than the defined state, that is, “else” for if, etc. There was a problem that we could not do it.

  An object of the present invention is to output source code representing conditional branches of all exception events.

A source code generation system according to the present invention includes:
A process item list storage unit that stores a process item list that includes a process item that represents a process item, operation information that represents an operation included in the process item, and exception process information that represents an exception process;
A behavior description information storage unit that stores behavior description information that describes the behavior of the processing item described based on the processing item list;
A behavior description generator for generating a source code defining a class using the processing items;
Using the operation information, an operation generation unit that generates a source code that defines the operation;
Using the exception handling information, an exception description generator for generating source code representing the exception handling that occurs during execution of the operation;
Using the behavior description information, a condition description generation unit that generates a source code representing a conditional branch of the operation;
A processing description generating unit that generates source code representing the processing content of the operation using the behavior description information;

  A source code generation system according to the present invention describes a processing item list storage unit that stores a processing item list including processing items, operation information, and exception processing information, and describes the behavior of the processing items described based on the processing item list A behavior description information storage unit for storing behavior description information to be generated, a behavior description generation unit for generating a source code for defining a class using process items, and a source code for defining an operation using operation information Since it includes an operation generation unit and an exception description generation unit that generates source code representing exception processing that occurs during execution of an operation using exception processing information, source code that represents exception processing that occurs during an operation is generated be able to.

1 is a block configuration diagram of a source code generation system 800 according to Embodiment 1. FIG. FIG. 3 is a diagram showing a flow from specification description to source code generation in the source code generation system 800 according to the first embodiment. The figure which shows the specific example of the physical item list | wrist 102 which concerns on Embodiment 1, and the procedure of preparation. The figure which shows the specific example and creation procedure of the behavior description 104 of the physical item which concerns on Embodiment 1. FIG. FIG. 6 is a diagram illustrating a specific example of a function item list 103 according to the first embodiment and a creation procedure. The figure which shows the specific example and procedure of creation of the behavior description 105 of the function item which concerns on Embodiment 1. FIG. The source code generation method in the source code generation device 20 concerning Embodiment 1, and a flow figure showing operation of source code generation processing S10. The figure which shows the example of the source code produced | generated from the physical item list which concerns on Embodiment 1, and the behavior description of a physical item. The figure which shows the example of the source code produced | generated from the function item list | wrist which concerns on Embodiment 1, and the behavior description of a function item. 1 is a hardware configuration diagram of a source code generation device 20 according to Embodiment 1. FIG. The block block diagram of the source code generation system 800a which concerns on Embodiment 2. FIG. FIG. 11 is a flowchart showing an operation of priority control processing of a priority control unit 3031a that implements priority control source code 3031 according to the second embodiment. The figure which shows the example of the inheritance relationship of each function by the priority control part 3031a which concerns on Embodiment 2. FIG.

Embodiment 1 FIG.
A block configuration of the source code generation device 20 according to the present embodiment will be described with reference to FIG.
In the present embodiment, exception events that may occur for physical items, processing priorities for function items, specification description methods, and code generation methods are shown.

*** Explanation of configuration ***
The source code generation system 800 includes a processing item list storage unit 1071, a behavior description information storage unit 1081, a source code generation device 20, and a source code 30.
The source code generation device 20 includes an acquisition unit 40, a source code generation unit 50, and a priority control generation unit 60.
The acquisition unit 40 receives the physical item list 102, the function item list 103, the physical item behavior description 104, and the functional item behavior description 105.

The physical item list 102 and the function item list 103 are examples of the processing item list 107.
The physical item behavior description 104 and the function item behavior description 105 are examples of the behavior description information 108.

  The process item list storage unit 1071 stores a process item list 107 including a process item 1072 representing a process item, operation information 1073 representing an operation included in the process item 1072, and exception process information 1074 representing an exception process. . The processing item list storage unit 1071 stores the physical item list 102 and the function item list 103 as the processing item list 107.

The behavior description information storage unit 1081 stores behavior description information 108 that describes the behavior of the processing item 1072 described based on the processing item list 107. The behavior description information storage unit 1081 stores a physical item behavior description 104 and a function item behavior description 105 as the behavior description information 108.
The process item list 107 includes operation information 1073 representing a plurality of operations 1073a as operations.

The source code generation unit 50 includes a behavior description generation unit 501, an operation generation unit 502, an exception description generation unit 503, a condition description generation unit 504, and a process description generation unit 505.
The behavior description generation unit 501 uses the processing item 1072 to generate a source code that defines a class.
The operation generation unit 502 uses the operation information 1073 to generate source code that defines the operation. The operation generation unit 502 generates source code that defines each operation of a plurality of operations.
The exception description generation unit 503 uses the exception processing information 1074 to generate source code representing exception processing that occurs during operation execution. The exception description generation unit 503 assigns source code representing exception processing to source code defining each operation of a plurality of operations.
The condition description generation unit 504 uses the behavior description information 108 to generate source code representing a conditional branch of the operation.
The process description generation unit 505 uses the behavior description information 108 to generate a source code that represents the processing content of the operation.

Each component will be described in more detail.
The behavior description generation unit 501 generates one class for every physical item and function item defined in the physical item list 102 and the function item list 103. Here, the class is generated in the form of source code. As the class name, a label name defined for each physical item and function item, that is, for each processing item 1072 is used.
Next, in the physical item list 102 and the function item list 103, that is, the processing item list 107 in which the upper item of the item is defined, there is a parent-child relationship with the class generated from the item of the upper item. Generate inheritance code that indicates The behavior description generation unit 501 adds the generated inheritance code to a class generated in the form of source code.

  The operation generation unit 502 generates one method for every operation defined in the physical item list 102 and the function item list 103, and arranges it in the function class to which the operation belongs. Here, the method is generated in the form of source code. Use the label name defined for each operation as the method name. Generating a method source code means generating a source code that defines an operation.

  The exception description generation unit 503 generates an exception code for each exception defined in the physical item list 102, and places the exception code in all methods of the physical item to which the exception belongs.

  The condition description generation unit 504 generates an if statement having the same contents for all condition descriptions defined by the behavior description 104 of the physical item and the behavior description 105 of the function item, that is, the behavior description information 108. Here, the attribute name used as the determination target of the if statement is defined by pairing the attribute name and the label in the physical item list 102 or the function item list 103, and the label is used for the source code. The generated if statement is arranged in the order described in the operation source code defined in the behavior description 104 of the physical item and the behavior description 105 of the function item.

  The process description generation unit 505 generates control statements having the same contents for all process descriptions defined in the physical item behavior description 104 and the function item behavior description 105. The attribute name used in the control statement is defined by pairing the attribute name and the label in the physical item list 102 or the function item list 103, and the label is used for the source code. The generated control statements are arranged in the order described in the operation source code defined in the behavior description 104 of the physical item and the behavior description 105 of the function item.

The priority control generation unit 60 compares the priority of the process item being executed with the priority of the process item requested to be executed based on the priority 1075 set for each of the process items 1072, and the priority A priority control source code 303 having a priority control function for executing a process item having a higher value is generated.
Note that the priority control generation unit 60 may not be provided, and a configuration may be adopted in which a function priority control program is included in the source code of each function.

A flow from specification description to source code generation in the source code generation system 800 according to the present embodiment will be described with reference to FIG.
The hardware is extracted from the input specification 101 in which the specifications are described, and the definitions of exception items that may occur such as failure, power interruption, abnormal value detection, etc. are listed in the physical item list 102. Also, software functions are extracted from the input specification 101 and the definition of priority is listed in the function item list 103.

For each item in the physical item list 102, an exception and a behavior when an exception occurs are defined in the behavior description 104 of the physical item using a Japanese behavior description language.
For each item in the function item list 103, a function behavior definition is described in the function item behavior description 105.

  The physical item list 102, the physical item behavior description 104, the function item list 103, and the function item behavior description 105 are input to the source code generation device 20 to generate the source code 30 of the physical item class 301 and the function item class 302. To do.

  A specific example and creation procedure of the physical item list 102 according to the present embodiment will be described with reference to FIG. In the physical item list 102, hardware items are expressed in a hierarchy.

The physical item is an example of a processing item 1072 that represents a class that is a processing item.
The physical item list 102, that is, the processing item list 107 has a plurality of processing items 1072 a as the processing items 1072. Each of the plurality of process items 1072a has a parent process item 10721 which is a higher hierarchy. The top-level process item has no parent process item.
Specifically, in the physical item list 102, for each physical item, a name that is a physical name and a label that is used when generating the source code are described hierarchically. The physical items are refined as the hierarchy goes down.
As the names of the physical items, sensors 1 and 2 are described below the sensor hierarchy, and as the physical item labels, Sensor corresponding to the sensor, Sen1 corresponding to the sensor 1, and Sen2 corresponding to the sensor 2 are described. .
For example, the sensor is a parent physical item, that is, a parent processing item 10721, and the sensor 1 and sensor 2 are child physical items, that is, a child processing item 10722.

  In addition, an operation name and an operation label are described for each physical item. In FIG. 3, activation and value acquisition are described as names of operations of the sensor 1, and respective labels OpeY and OpeZ are described.

  For each operation, the attribute name, attribute label, attribute range, and initial attribute value are described. Attributes common to all operations are listed on lines that do not belong to any operation. In FIG. 3, the name of the attribute called the power supply state common to the operations called “startup” and “value acquisition” is shown. For the attribute name “power state”, the label is AttrN and the range is POWERON and POWEROFF.

  If there is an exception item for the physical item, describe the exception name and exception label. In FIG. 3, for the name of the physical item “sensor 1”, an exception name “power off” and an exception label “POWEROffEvent” are shown.

A specific example of the physical item behavior description 104 according to the present embodiment and a procedure for creating the physical item will be described with reference to FIG.
A physical item behavior description 104 is created for each physical item in the physical item list 102. In FIG. 4, the behavior description of “sensor 1” is described.
The physical item behavior description 104 describes the physical item behavior description after describing the name, outline, and purpose of the physical item.

In the physical item list 102, if there is an exception process for a physical item for which a behavior description is to be created, the name of the exception is entered in brackets [].
In addition, a process description representing a process is prefixed with.
FIG. 4 describes a process of setting the power state to POWER OFF when an exceptional process of “power failure” occurs.
In addition, operations are represented by parentheses <>, and the name of the operation is described in parentheses <>.

A specific example of the function item list 103 according to the present embodiment and a procedure for creating it will be described with reference to FIG. In the function item list 103, functions required for the system are expressed in a hierarchy.
The function item is an example of a processing item 1072 that represents a class that is a processing item.
The function item list 103, that is, the process item list 107 has a plurality of process items as process items, and a priority 1075 is set for each of the plurality of process items. Each of the plurality of process items has a parent process item that is a higher hierarchy. The top-level process item has no parent process item. The priority level described below is an example of a priority 1075.

In the function item list 103, first, a function requested by the system is extracted. Then, the extracted functions are arranged hierarchically such as major classification, middle classification, and minor classification. There is no need to limit the depth of the hierarchy, and the depth of the hierarchy may be different depending on the function.
In the example of FIG. 5, function names are set in the function item column in order from the upper layer. The major classification is set as function A, and the middle classification is set as function A1 and function A2. Further, the major classification is set as function B, the middle classification is set as function B1 and function B2, and the minor classification of function B2 is set as function B21 and function B22. In addition, there is no restriction | limiting in the name used for the name of a function here, ie, a character string.
For example, function A is a parent function item, that is, a parent process item, and function A1 and function A2 are child function items, that is, a child process item. If the child function items, that is, the child process items are the function B21 and the function B22, the parent function item, that is, the parent process item is the function B2.

Next, the priority 1075 required by the system for each function is considered. The priority 1075 indicates an execution priority between functions classified in the same hierarchy. In the example of FIG. 5, the priority levels of the function A and the function B are 1 and 2, respectively. Therefore, the priority of the function A is higher than the priority of the function B.
As the priority, it is necessary to specify a unique value between functions having the same upper layer function. On the other hand, priority values may be duplicated between functions having different upper layers. In the example of FIG. 5, the priority levels of the middle-class function A1 and function A2 whose upper layer is function A are 1 and 2, respectively. In addition, 1 and 2 are set for the priority levels of the functions B1 and B2 of the medium classification whose functions are the same middle class but whose upper layer is the function B, respectively.

  Next, a label is set for each function. This is used for the class name when generating the source code. Therefore, it is necessary to name the generated code according to the programming language specification.

  Subsequently, a specific specification of each function defined in the creation of the function item list 103 is defined as a function specification. The functional specification is an example of the operation information 1073. Functional specifications are roughly classified into operations and attributes.

First, in the operation item, the processing contents necessary for each function are extracted, and a name is given to the processing. This name must be unique within a function.
Next, a label is set for each extracted operation. This is used for the method name when generating the source code. Therefore, it is necessary to name the generated code according to the programming language specification.

Next, in the attribute item, data used in each operation is extracted, and a name is given to the extracted data. The name given to the extracted data needs to be unique within one operation.
Set a label for each extracted attribute. This label is used as a field name when generating source code. Therefore, it is necessary to name the generated code according to the programming language specification.
In addition, the range of each extracted attribute is set as a range. This is used for the field range when generating source code. Therefore, a value in a range that cannot exist as a field cannot be set.
Furthermore, the initial value of each extracted attribute is set. This is used for field initialization when generating source code. Therefore, a value in a range that cannot exist as a field cannot be set.

A specific example of the function item behavior description 105 according to the present embodiment and a procedure for creating the function item will be described with reference to FIG.
In the function item behavior description 105, the behavior of each function defined in the function item list 103 is defined, and details of processing contents are described for each operation of each function.

First, for each operation of the function, examine how to use the attribute belonging to the operation, and clarify what kind of “processing” should be performed under what “condition”. .
Next, the studied “conditions” and “processing” are described in a pseudo language. In this pseudo language, the attributes to be used are aligned with the names described in the function item list 103, and only the logical structure is symbolized.

All operations of one function are collectively described as one “function item behavior description”.
That is, the operation A and the operation B included in the function A1 in the function item list 103 in FIG. 5 are collectively described in one “function item behavior description 105” illustrated in FIG.
The above procedure is performed for all functions in the function item list 103.

*** Explanation of operation ***
The operation of the source code generation method and source code generation processing S10 in the source code generation device 20 according to the present embodiment will be described using FIG.

The acquisition unit 40 executes an acquisition process S100 that acquires the process item list 107 and the behavior description information 108 that describes the behavior of the process item 1072 described based on the process item list 107.
Specifically, in S701, the acquisition unit 40 acquires the physical item list 102, the function item list 103, the physical item behavior description 104, and the functional item behavior description 105.
If there is no unprocessed item for the physical item behavior description 104 or the functional item behavior description 105 acquired by the acquisition unit 40, the behavior description generation unit 501 terminates the process, and there is an unprocessed item. If so, the process proceeds to S702.
Here, the behavior description of the processing target is the processing target behavior description.

The behavior description generation unit 501 executes a behavior description generation process S100a that generates a source code that defines a class using the processing item 1072.
Specifically, in S702, the behavior description generation unit 501 acquires the function name or physical name label of the processing target behavior description from the function item list 103 or the physical item list 102 based on the processing target behavior description, and class Is generated.

For example, when the processing target behavior description is the physical item behavior description 104, the behavior description generation unit 501 generates source code that defines a class for “sensor 1” based on the physical item list 102 of FIG. 3. First, the behavior description generation unit 501 acquires the label of the behavior description “sensor 1” from the physical item list 102 and generates the Sen1 class, which is the physical item class 301, as a source code. Specifically, the behavior description generation unit 501 generates “Class Sen1” on the first line in FIG.
For example, if the behavior description to be processed is the behavior description 105 of the function item, the behavior description generation unit 501 generates a source code for “function A1” based on the function item list 103 of FIG. First, the behavior description generation unit 501 acquires the label of the behavior description “function A1” from the function item list 103, and generates the Class A1 class that is the function item class 302 as a source code. Specifically, the behavior description generation unit 501 generates “class Class A1” on the first line in FIG.

  After the generation of the class source code in S702, if there is a parent function item or a parent physical item for the function item or physical item of the processing target behavior description, the process proceeds to S703. If there is no parent function item or parent physical item for the function item or physical item in the processing target behavior description, the process proceeds to S704.

  In S703, the behavior description generation unit 501 executes the inheritance description process S200. The behavior description generation unit 501 acquires the label of the name of the parent function item or the parent physical item from the function item list 103 or the physical item list 102 based on the processing target behavior description, and generates an inheritance code.

When the behavior description to be processed is the physical item list 102 in FIG. 3, the behavior description generation unit 501 acquires the label “Sensor” of “Sensor” because the sensor 1 has “Sensor” as a parent physical item. The behavior description generation unit 501 generates an inheritance description to the parent class “Sensor” for the source code “class Sen1” generated in S702. Specifically, the behavior description generation unit 501 generates “: public Sensor” on the first line in FIG.
When the processing target behavior description is the function item list 103 of FIG. 5, the behavior description generation unit 501 obtains the label ClassA of “function A” because “function A” is the parent function item in the function A1. To do. The behavior description generation unit 501 generates an inheritance description to the parent class “ClassA” for the source code “class ClassA1” generated in S702. Specifically, the behavior description generation unit 501 generates “: public ClassA” on the first line in FIG.

  In step S <b> 704, the operation generation unit 502 determines whether there is an unprocessed operation based on the processing target behavior description. If there is an unprocessed operation, the operation generation unit 502 advances the process to S705. If there is no unprocessed operation, the operation generation unit 502 advances the process to S708.

The operation generation unit 502 executes an operation generation process S300 for generating a source code that defines an operation using the operation information 1073.
Specifically, in step S <b> 705, the operation generation unit 502 acquires a label of an unprocessed operation name from the function item list 103 or the physical item list 102 and generates a method.

For example, in the case of the physical item list 102 in FIG. 3, the operation generation unit 502 acquires the label and generates a method as the source code because the sensor 1 has the operation “activation”. Specifically, the operation generation unit 502 generates “void OpeY ()” on the second line in FIG.
Further, for example, in the case of the function item list 103 in FIG. 5, the operation generation unit 502 obtains a label and generates a method as source code because the function A has the operation “operation A”. Specifically, the operation generation unit 502 generates “void OpeA ()” on the second line in FIG.

The exception description generation unit 503 executes exception description generation processing S400 that generates source code representing exception processing that occurs during the execution of an operation using the exception processing information 1074.
In step S706, the exception description generation unit 503 determines whether there is an unprocessed exception description in the processing target behavior description. If there is an unprocessed exception description, the exception description generation unit 503 advances the process to S707. Also, if there is no unprocessed exception description, the exception description generation unit 503 advances the process to S704.

In step S707, the exception description generation unit 503 acquires an exception name label from the physical item list 102, and adds an exception code to the operation.
For example, in the case of the physical item list 102 in FIG. 3, the exception description generation unit 503 obtains the label “Power off” because the sensor 1 has the exception item “Power off”, and adds an exception code to the “Start” method. Add Specifically, the exception description generation unit 503 generates source code as shown in the third and fifth lines of FIG.

The condition description generation unit 504 executes a condition description generation process S500 for generating source code representing a conditional branch of an operation using the behavior description information 108.
In S708, the condition description generation unit 504 advances the process to S709 if there is an unprocessed condition description in the processing target behavior description. If there is no unprocessed condition description, the condition description generation unit 504 advances the process to S710.

In step S709, the condition description generation unit 504 acquires an attribute name label in the condition description and generates an if statement.
For example, in the case of the function item list 103 in FIG. 5, the condition description generation unit 504 has a condition description in the operation “operation A”, so the attribute names “attribute B” “attribute C” “attribute D” “ The label of the attribute “E” is acquired from the function item list 103, and an “if” statement is generated. Specifically, the condition description generation unit 504 generates source code as in the third and sixth lines in FIG.

The process description generation unit 505 executes a process description generation process S600 that generates a source code representing the process contents of the operation using the behavior description information 108.
In step S710, the process description generation unit 505 determines whether there is an unprocessed process description in the process target behavior description. If there is an unprocessed process description, the process description generation unit 505 advances the process to S711. If there is no unprocessed process description, the process description generation unit 505 advances the process to S701.

In step S <b> 711, the process description generation unit 505 acquires the attribute name label in the process description and generates a control statement.
For example, in the case of the function item list 103 in FIG. 5, the process description generation unit 505 acquires the label of the attribute name “attribute F” in the condition description because there is an unprocessed process description in the operation “operation A”. Generate control statements. Specifically, the process description generation unit 505 generates source code as in the fourth and seventh lines of FIG.

FIG. 8 shows an example of the source code 30 of the physical item class 301. FIG. 9 shows an example of the source code 30 of the function item class 302.
Through the above source code generation processing S10, the source code 30 as shown in FIGS. 8 and 9 is automatically output.

The source code generation unit 50 outputs the source code 30 of the physical item class 301 and the function item class 302.
The priority control generation unit 60 compares the priority level of the function item being executed with the priority level of the function item requested to be executed based on the priority level set for each function item. The priority control generation unit 60 generates a priority control source code 303 having a priority control function for executing a function item having a higher priority level.

The hardware configuration of the source code generation device 20 according to this embodiment will be described with reference to FIG.
The source code generation device 20 is a computer.
The source code generation device 20 includes hardware such as a processor 901, an auxiliary storage device 902, a memory 903, a communication device 904, an input interface 905, and a display interface 906.
The processor 901 is connected to other hardware via the signal line 910, and controls these other hardware.
The input interface 905 is connected to the input device 907.
The display interface 906 is connected to the display 908.

The processor 901 is an IC (Integrated Circuit) that performs processing.
The processor 901 is, for example, a CPU (Central Processing Unit), a DSP (Digital Signal Processor), or a GPU (Graphics Processing Unit).
The auxiliary storage device 902 is, for example, a ROM (Read Only Memory), a flash memory, or an HDD (Hard Disk Drive).
The memory 903 is, for example, a RAM (Random Access Memory).
The communication device 904 includes a receiver 9041 that receives data and a transmitter 9042 that transmits data.
The communication device 904 is, for example, a communication chip or a NIC (Network Interface Card).
The input interface 905 is a port to which the cable 911 of the input device 907 is connected.
The input interface 905 is, for example, a USB (Universal Serial Bus) terminal.
The display interface 906 is a port to which the cable 912 of the display 908 is connected.
The display interface 906 is, for example, a USB terminal or an HDMI (registered trademark) (High Definition Multimedia Interface) terminal.
The input device 907 is, for example, a mouse, a keyboard, or a touch panel.
The display 908 is, for example, an LCD (Liquid Crystal Display).

The auxiliary storage device 902 includes a behavior description generation unit 501, an operation generation unit 502, an exception description generation unit 503, a condition description generation unit 504, and a process description generation unit 505 (hereinafter, a behavior description generation unit 501, an operation generation). A program that realizes the function of the unit 502, the exception description generation unit 503, the condition description generation unit 504, and the process description generation unit 505.
This program is loaded into the memory 903, read into the processor 901, and executed by the processor 901.
Further, the auxiliary storage device 902 also stores an OS (Operating System).
Then, at least a part of the OS is loaded into the memory 903, and the processor 901 executes a program that realizes the function of “unit” while executing the OS.
Although one processor 901 is illustrated in FIG. 10, the source code generation device 20 may include a plurality of processors 901.
A plurality of processors 901 may execute a program for realizing the function of “unit” in cooperation with each other.
In addition, information, data, signal values, and variable values indicating the results of the processing of “unit” are stored as files in the memory 903, the auxiliary storage device 902, or a register or cache memory in the processor 901.

The “part” may be provided as “circuitry”.
Further, “part” may be read as “circuit”, “process”, “procedure”, or “processing”.
“Circuit” and “Circuitry” include not only the processor 901 but also other types of processing circuits such as a logic IC or GA (Gate Array) or ASIC (Application Specific Integrated Circuit) or FPGA (Field-Programmable Gate Array). It is a concept to include.
Note that what is called a program product is a storage medium, a storage device, or the like on which a program that realizes the function described as a “part” is recorded. It is what you are loading.

*** Explanation of effects ***

  In the source code generation device 20 according to the present embodiment, in addition to automatic generation of normal descriptions such as source code templates, condition descriptions, and process descriptions, automatic generation of source codes taking into account exceptions and processing priorities is performed. It becomes possible. Therefore, there is an effect of reducing the source code creation time.

  In the source code generation device 20 according to the present embodiment, each operation defined in the physical item list is generated as a source code from a physical item list in which an arbitrary exception is defined for a hardware physical item. All exception source codes for the same hardware physical item are allocated to the generated source codes of all operations. By such processing, the exception description generation unit automatically generates exception processing source code for each exception processing for a plurality of operations belonging to the hardware physical item. As described above, in the source code generation device 20 according to the present embodiment, it is possible to further increase the effect of reducing the creation time by automatically outputting the conditional branches of all exceptional events.

  Since the source code generation apparatus 20 according to the present embodiment includes the priority control generation unit, it is not necessary to have a function priority control program in the source code of each function. As a result, the amount of source code can be reduced. Further, the priority control function enables switching in consideration of the function priority.

Embodiment 2. FIG.
In the present embodiment, differences from the first embodiment will be mainly described.
In the present embodiment, a specification description method and a code generation method for processing priority for function items will be described.

*** Explanation of configuration ***
The block configuration of the source code generation system 800a according to this embodiment will be described with reference to FIG.
The source code generation device 20a according to the present embodiment can be executed in consideration of the priority of each function item.

  As illustrated in FIG. 11, the source code generation device 20 a includes a priority control generation unit 601 and a priority control source code 3031 instead of the priority control generation unit 60 and the priority control source code 303 according to the first embodiment. Have. The priority control generation unit 601 generates priority control source code 3031.

The priority control generation unit 601 determines the process item requested to be executed based on the priority 1075a of the parent process item of the process item being executed and the priority of the parent process item of the process item requested to be executed. A priority control source code 3031 having a priority control function for determining whether or not execution is possible is generated.
When there is a process item being executed having a parent process item different from the parent process item of the process item requested to be executed, the priority control generation unit 601 gives priority to the parent process item of the process item requested to be executed. And the priority of the parent process item of the process item being executed are compared. The priority control generation unit 601 can omit the comparison of different child items by disabling execution of the process item having the parent process item with the lower priority.

*** Explanation of operation ***
The procedure of the priority control process of the priority control unit 3031a that realizes the priority control source code 3031 according to the present embodiment will be described with reference to FIG. Here, a component that realizes the priority control function of the priority control source code 3031 is referred to as a priority control unit 3031a.

In S1201, the priority control unit 3031a acquires the priority level of the function item of the execution request.
In S1202, the priority control unit 3031a determines the priority level. If the priority level is 0, the process proceeds to S1212.
If the priority level is other than 0, the priority control unit 3031a proceeds to S1203 and acquires the function information being executed.

In S1204, when there is no function being executed, the priority control unit 3031a proceeds to the execution permission of S1212.
If there is a function being executed, the priority control unit 3031a determines whether there is a function being executed of a different parent class in S1205. The parent class is a parent function item, that is, a parent processing item.
If there is an executing function of a different parent class, the priority control unit 3031a proceeds to S1207.
If there is no executing function of a different parent class, the priority control unit 3031a proceeds to S1206.

  In S1206, the priority control unit 3031a determines whether or not there is an executing function of the same parent class. If there is an executing function of the same parent class, the priority control unit 3031a proceeds to S1209. If there is no executing function of the same parent class, the priority control unit 3031a proceeds to S1212 to permit execution.

  In S1207, the priority control unit 3031a compares the priority levels of the parent classes of the function being executed and the execution request function. In S1208, when the priority level of the parent class of the execution request function is low as a result of the comparison of the priority levels of the parent class of the function being executed and the execution request function, the priority control unit 3031a does not permit the execution of S1211. . If the priority level of the parent class of the execution request function is high, the priority control unit 3031a proceeds to S1206.

In S1209, the priority control unit 3031a compares the priority levels of the executing function and the execution request function of the same parent class, and when the priority level of the execution request function is high, the execution permission of S1212 is set. If the priority level of the execution request function is low, the priority control unit 3031a does not permit the execution of S1211.
This is the end of the description of the priority control processing procedure.

Next, an example of the inheritance relationship of each function by the priority control unit 3031a according to the present embodiment will be described with reference to FIG.
In the case of the function B2, in order to determine the execution permission, the execution permission determination is performed in consideration of the priority level of the function B which is the parent class. The parent class reference method uses the reference function of the inherited class of each language.
For example, when the function A2 is an execution request function and the functions B1 and B2 are executing functions, the parent classes of the function A2, the function B1, and the function B2 are different. Therefore, when the priority levels of the parent classes are compared, the priority level “1” of the function A that is the parent class of the function A2 is lower than the priority level “2” of the function B that is the parent class of the functions B1 and B2. Therefore, the function A cannot be executed without comparing the priority levels of the function A2 and each of the functions B1 and B2.

*** Explanation of effects ***
In the source code generation device 20a according to the present embodiment, the function being executed is managed for each higher-level function according to the hierarchy, and the priority comparison is performed step by step. Compare the higher-level functions of the function to be activated with the higher-level functions of the function being executed, and narrow down the comparison target. Next, priorities are compared between functions in the same hierarchy. As a result, the number of comparison targets can be reduced, and the processing time can be shortened.

  In the source code generation device 20a according to the present embodiment, the priority order control is not included in the source code of each function, but is aggregated into execution priority control having a role of function priority control. Can be reduced.

  In the source code generation device 20 according to the present embodiment, it is not necessary to compare the priorities of the function to be activated and all the functions being executed, and the priority comparison processing time can be shortened.

In the above embodiment, the acquisition unit 40, the behavior description generation unit 501, the operation generation unit 502, the exception description generation unit 503, the condition description generation unit 504, the process description generation unit 505, and the priority control generation unit 60 are independent of each other. The source code generation device 20 is configured as a functional block. However, the configuration of the source code generation device 20 is arbitrary. Further, the behavior description generation unit 501, the operation generation unit 502, the exception description generation unit 503, the condition description generation unit 504, and the process description generation unit 505 may be realized by one functional block. Further, the source code generation unit 50 may include the function of the priority control generation unit 60.
The function blocks of the source code generation device 20 are arbitrary as long as the functions described in the embodiment can be realized, and the file management device may be configured by any combination of these function blocks. Absent.

Although the first and second embodiments have been described above, one of the two embodiments may be partially implemented. Alternatively, a plurality of these two embodiments may be partially combined. In addition, these two embodiments may be implemented in any combination as a whole or in part.
In addition, said embodiment is an essentially preferable illustration, Comprising: It does not intend restrict | limiting the range of this invention, its application thing, or a use, A various change is possible as needed. .

  20, 20a Source code generation device, 30 source code, 40 acquisition unit, 50 source code generation unit, 60, 601 priority control generation unit, 101 input specification, 102 physical item list, 103 function item list, 104 physical item Behavior description, 105 Function item behavior description, 107 Process item list, 108 Behavior description information, 301 Physical item class, 302 Function item class, 303, 3031 Priority control source code, 501 Behavior description generation unit, 502 Operation generation unit, 503 Exception description generation unit, 504 Condition description generation unit, 505 Process description generation unit, 800, 800a Source code generation system, 901 processor, 902 auxiliary storage device, 903 memory, 904 communication device, 905 input interface, 906 display Interface, 907 input device, 908 display, 910 signal line, 911, 912 cable, 1071 processing item list storage unit, 1072 processing item, 1072a multiple processing items, 1073 operation information, 1073a multiple operations, 1074 exception processing information, 1075 Priority, 1075a Priority of parent process item of the process item being executed, 1075b Priority of parent process item of the process item requested to be executed, 1081 Behavior description information storage unit, 3031a Priority control unit, 9041 Receiver, 9042 Transmitter, 10721 Parent processing item, 10722 Child processing item, S10 Source code generation processing, S100 acquisition processing, S100a Behavior description generation processing, S200 Inheritance description processing, S300 Operation generation processing, S400 Exception description generation processing S500, condition description generation process, S600 process description generation process.

Claims (8)

A process item list storage unit that stores a process item list that includes a process item that represents a process item, operation information that represents an operation included in the process item, and exception process information that represents an exception process;
A behavior description information storage unit that stores behavior description information that describes the behavior of the processing item described based on the processing item list;
A behavior description generator for generating a source code defining a class using the processing items;
Using the operation information, an operation generation unit that generates a source code that defines the operation;
Using the exception handling information, an exception description generator for generating source code representing the exception handling that occurs during execution of the operation;
Using the behavior description information, a condition description generation unit that generates a source code representing a conditional branch of the operation;
A source code generation system comprising: a process description generation unit that generates a source code representing the processing content of the operation using the behavior description information. The processing item list is:
The operation information representing a plurality of operations as the operation,
The operation generator is
Generating source code defining each operation of the plurality of operations;
The exception description generation unit
The source code generation system according to claim 1, wherein source code representing the exception processing is assigned to source code defining each operation of the plurality of operations. The processing item list is:
As the processing item, it has a plurality of processing items, and a priority is set for each of the plurality of processing items,
The source code generation system includes:
Based on the priority set for each of the process items, the priority of the process item being executed is compared with the priority of the process item requested to be executed, and the process item with the higher priority is executed. The source code generation system according to claim 1, further comprising a priority control generation unit that generates a priority control source code having a priority control function. The processing item list is:
As the processing item, it has a plurality of processing items,
A priority is set for each of the plurality of processing items, and each of the plurality of processing items has a parent processing item that is a higher hierarchy,
Priority control that determines whether or not a process item requested to be executed can be executed based on the priority of the parent process item of the process item being executed and the priority of the parent process item of the process item requested to be executed The source code generation system according to claim 1, further comprising a priority control generation unit that generates a priority control source code having a function. The priority control generation unit
When there is a process item being executed having a parent process item different from the parent process item of the process item requested to be executed, the priority of the parent process item of the process item requested to be executed and the process being executed 5. The source code generation system according to claim 4, wherein the priority of the parent processing item of the item is compared, and execution of the processing item having the parent processing item with the lower priority is prohibited. A process item representing a process item, operation information representing an operation included in the process item, exception process information representing an exception process, and the process item described based on the process item list An acquisition unit for acquiring behavior description information describing the behavior of
A behavior description generator for generating a source code defining a class using the processing items;
Using the operation information, an operation generation unit that generates a source code that defines the operation;
Using the exception handling information, an exception description generator for generating source code representing the exception handling that occurs during execution of the operation;
Using the behavior description information, a condition description generation unit that generates a source code representing a conditional branch of the operation;
A source code generation device comprising: a process description generation unit that generates a source code representing the processing content of the operation using the behavior description information. A process item list storage unit that stores a process item that includes a process item that represents a process item, operation information that represents an operation included in the process item, and exception process information that represents an exception process; and In a source code generation method of a source code generation system, comprising: a behavior description information storage unit that stores behavior description information that describes the behavior of the processing item described based on
The behavior description generator generates source code that defines a class using the processing items,
An operation generation unit that generates a source code that defines the operation using the operation information;
An exception description generation unit generates source code representing the exception processing that occurs during execution of the operation using the exception processing information;
A condition description generation unit generates source code representing a conditional branch of the operation using the behavior description information,
A source code generation method in which a process description generation unit generates a source code representing the processing content of the operation using the behavior description information. A process item representing a process item, operation information representing an operation included in the process item, exception process information representing an exception process, and the process item described based on the process item list Acquisition processing for acquiring behavior description information describing the behavior of
A behavior description generation process for generating a source code for defining a class using the processing items;
An operation generation process for generating a source code defining the operation using the operation information;
Exception description generation processing for generating source code representing the exception processing that occurs during execution of the operation using the exception processing information;
A condition description generation process for generating a source code representing a conditional branch of the operation using the behavior description information;
A program for causing a computer to execute a process description generating process for generating a source code representing the processing contents of the operation using the behavior description information.

Images