DESCRIPTION
SOURCE-CODE-GENERATION SUPPORTING PROGRAM AND SOURCE-CODE-
GENERATION SUPPORTING.METHOD
TECHNICAL FIELD
The present invention relates to a source-code-
generation supporting program and a source-code-generation
supporting method that support generation of a source code
based on object oriented techniques, and, more particularly
to a source-code-generation supporting program and a
source-code-generation supporting method that can improve
the efficiency of program development by reusing an
existing source code.
BACKGROUND ART
Recently, program codes are generated based on object
oriented techniques to make program developments efficient.
According to the object oriented techniques, data and
processing are stored as one object, and a program code is
described by sending a message for invoking the processing
to the object.
On the other hand, there is an attempt to
automatically generate a program code corresponding to a
specification based on the specification of the program
code desired by a user. However, since a processing logic
for generating the program code is incomplete, only a
template of the program code desired by the user can be
generated (see, for example, Patent Document 1). That is,
to generate a complete program code, the user has to
overwrite the program code using a simple script language.
To solve this problem, there is proposed a technique
in which a program code and a configuration of the program
code are generated in association with each other, and when
a user edits the configuration, the editing on the
configuration is reflected in the corresponding program
code, thereby enabling generation of a new program code
(see, for example, Patent Document 2) . In addition, Patent
Document 3 discloses a technique that automatically manages
consistency of a specification relating to the program code.
Patent Document 1: Japanese Patent Application Laid-
Open No. H11-219287
Patent Document 2: Japanese Patent No. 3299259
Patent Document 3: Japanese Patent Application Laid-
Open No. H11-3216
In the conventional techniques, however, a program
code equivalent to a new program code to be generated needs
to be described beforehand, which imposes a heavy burden on
users.
Furthermore, when a new program code that does not
correspond to the configuration of the pre-generated
program code is generated, the new program code cannot be
generated by editing the configuration, and users need to
newly generate the program code, thereby deteriorating the
efficiency of program code generation.
The present invention has been achieved to solve the
problems in the conventional techniques, and it is an
object of the present invention to provide a source-code-
generation supporting program and a source-code-generation
supporting method that can eliminate the burden on the user
and can generate the program code efficiently.
DISCLOSURE OF INVENTION
To solve the above problems and to achieve the object,
a source-code-generation supporting program according to
one aspect of the present invention is for supporting
generation of a source code based on object orientation,
causing a computer to execute a tree-structure generating
procedure of generating tree-structured data based on a
sequence diagram indicating a specification of a new source
code to be generated; a retrieving procedure of retrieving
tree-structured data matching with the tree-structured data
generated at the tree-structure generation procedure from a
storing unit that stores at least an existing source code
and tree-structured data corresponding to the existing
source code; and an acquiring procedure of acquiring a
source code corresponding to the matching tree-structured
data from the storing unit.
A source-code-generation supporting method according
to another aspect of the present invention is for
supporting generation of a source code based on object
orientation, including a tree-structure generating step of
generating tree-structured data based on a sequence diagram
indicating a specification of a new source code to be
generated; a retrieving step of retrieving tree-structured
data matching with the tree-structured data generated at
the tree-structure generation step from a storing unit that
stores at least an existing source code and tree-structured
data corresponding to the existing source code; and an
acquiring step of acquiring a source code corresponding to
the matching tree-structured data from the storing unit.
According to the present invention, the tree-
structured data is generated based on the sequence diagram
indicating the specification of the source code to be newly
generated, tree-structured data matching with the generated
tree-structured data is retrieved from the storing unit
that stores at least existing source codes and tree-
structured data corresponding to the existing source codes,
and the source code corresponding to the matching tree-
structured data is obtained from the storing unit.
Accordingly, it is not necessary to develop the source code
from scratch, and a desired source code can be generated
only by specifying the sequence diagram. As a result, the
burden on the user can be eliminated, and the efficiency of
program development can be improved.
BRIEF DESCRIPTION OF DRAWINGS
Fig. 1 depicts a concept of program reuse performed by
a source-code generation apparatus according to an
embodiment;
functional
Fig. 2 is a function block diagram of a configuration
of a source-code-generation supporting apparatus;
Fig. 3 is one example of a list structure of a
sequence diagram;
Fig. 4 is one example of a data structure of tree-
structured data;
Fig. 5 depicts tree-structured data generated based on
the sequence diagram data shown in Fig. 3;
Fig. 6 is one example of a correspondence table;
Fig. 7 is an explanatory diagram of allocation of
identification numbers with respect to cells in respective
tree-structured data;
Fig. 8 is a generation sequence diagram and tree-
structured data of the generation sequence diagram;
Fig. 9 is an explanatory diagram of conversion of an
instance name of a program code;
Fig. 10 is a flowchart of a process procedure in a
preparation process;
Fig. 11 is a flowchart of a process procedure in a
tree-structure-conversion process;
Fig. 12 is a flowchart of a process procedure in a
program generation process;
Fig. 13 is a flowchart of a process procedure in a
matching process;
Fig. 14 is a flowchart of a process procedure in a
cell selection process;
Fig. 15 depicts a computer system that executes a
source-code-generation supporting program according to the
embodiment; and
Fig. 16 is a functional block diagram of a
configuration of a main body unit 501 shown in Fig. 15.
BEST MODE(S) FOR CARRYING OUT THE INVENTION
Exemplary embodiments of a source-code-generation
supporting program and a source-code-generation supporting
method according to the present invention will be explained
in detail below with reference to the accompanying drawings.
The present invention is not limited to the embodiments.
In the present embodiment, while a source-code-generation
supporting apparatus in which respective functions are
configured physically independently is explained, the
respective functions can be realized by software to be
executed as a source-code-generation supporting program.
Embodiment
A concept of program reuse performed by the source-
code-generation supporting apparatus according to the
present embodiment is explained first. Fig. 1 depicts the
concept of program reuse performed by the source-code
generation apparatus according to the present embodiment.
A program code is generated by object oriented techniques
in the present embodiment.
The source-code-generation supporting apparatus in the
present embodiment obtains beforehand an existing program
code and a sequence diagram indicating a specification of
the program code, to generate tree-structured data based on
the obtained sequence diagram, and stores the tree-
structured data and the program code in association with
each other.
The tree-structured data is generated based on
sequence information of a method and connection information
of an instance by extracting a connection relationship
between the instance included in the sequence diagram and
the method. The instance is generated at the time of
executing the program, using a class as a model. The
method indicates a procedure to be performed between
respective instances.
When a new program code is to be generated by reusing
the existing program code, a sequence diagram of the
program code to be newly generated is obtained, to generate
tree-structured data based on the obtained sequence diagram,
and tree-structured data matching with the generated tree-
structured data is retrieved from the pre-generated tree-
structured data.
A program code corresponding to the matching tree-
structured data is extracted, and an instance name included
in the extracted program code is replaced by a new instance
name, thereby generating a new program code.
A configuration of the source-code-generation
supporting apparatus is explained next. Fig. 2 is a
functional block diagram of the configuration of a source-
code-generation supporting apparatus 100.
As shown in Fig. 2, the source-code-generation
supporting apparatus 100 includes an input receiving unit
110, an output unit 120, a control unit 130, and a storing
unit 140.
The input receiving unit 110 obtains data of the
sequence diagram, program codes, and the like from an input
device such as a keyboard (not shown) , and sends the
obtained data of the sequence diagram and the program code
to the control unit 130. The input receiving unit 110
converts the data of the sequence diagram to a
predetermined data structure (hereinafter, "sequence
diagram data") and sends the converted data to the control
unit 130.
Fig. 3 is one example of a list structure of the
sequence diagram data. As shown in Fig. 3, the sequence
diagram data includes an instance list 210 and a method
arrow list 220. Reference sign 200 denotes a sequence
diagram displayed by the sequence diagram data.
The instance list 210 includes "upper left coordinate",
"width", "height", "instance information", "lifeline
length", and "lifeline coordinate".
The "upper left coordinate" indicates a coordinate at
an upper left corner of a box 200a expressing an instance,
the "width" indicates a width of the box 200a expressing
the instance, and the "height" indicates a height of the
box 200a expressing the instance.
The "instance information" indicates an instance name
and a class name including the instance name recorded on
the box 200a expressing the instance. The "lifeline
length" indicates a length of a lifeline 200b, and the
"lifeline coordinate" indicates a coordinate of an apex of
the lifeline 200b.
For example, the instance list indicating the instance
box and the lifeline at the left end includes "(x1, y1)" as
the "upper left coordinate", "w1" as the "width", "h1" as
the "height", "a:Order" as the "instance information", "L1"
as the "lifeline length", and "Lx1, Ly1" as the "lifeline
coordinate". Explanations of other instance lists are
omitted.
The method arrow list 220 is explained next. As shown
in Fig. 3, the method arrow list 220 includes "start point
coordinate", "method name", "length", "line type",
"connection source class", and "connection destination
class".
The "start point coordinate" indicates a coordinate at
the left end of an arrow 200c, the "method name" indicates
a name of a method expressed by an arrow, the "length"
indicates a length of the arrow 200c, the "line type"
indicates a type of the line of the arrow 200c, the
"connection source class" indicates a connection source
class name of the arrow 200c, and the "Connection
destination class" indicates a connection-destination class
name of the arrow 200c.
For example, the method arrow list of an arrow at the
left end includes "(a1, b1)" as the "start point
coordinate", "recieveOrder" as the "method name", "11" as
the "length", "Solid" as the "line type", "none" as the
"connection source class", and "a:Order" as the "connection
destination class". Explanations of other method arrow
lists are omitted.
The output unit 120 receives the program code from the
control unit 130, and outputs the received program code.
The control unit 130 generates tree-structured data,
and reuses the existing program code to generate a new
program code. The control unit 130 includes a tree-
structure-conversion processing unit 130a, a matching
processing unit 130b, and a program-extraction processing
unit 130c.
The tree-structure-conversion processing unit 130a
receives the sequence diagram data and the program code
from the input receiving unit 110, and converts the
received sequence diagram data to tree-structured data.
The tree-structure-conversion processing unit 130a further
makes the storing unit 140 store the program code and the
tree-structured data as program code data 140a and object
tree-structured data 140b, respectively.
When the tree-structure-conversion processing unit
130a makes the storing unit 140 store the program code and
the tree-structured data, the tree-structure-conversion
processing unit 130a attaches specifying information for
specifying where the corresponding program code is stored
(hereinafter, "program-code specifying information") to the
tree-structured data.
Fig. 4 is one example of a data structure of the tree-
structured data. The tree-structured data shown in Fig. 4
includes a program-code specifying information area, a
method name area, a connection-destination class name area,
and a pointer area. Hereinafter, the method name area, the
connection-destination class name area, and the pointer
area are collectively referred to as a cell (a top cell of
the tree-structured data includes the program-code
specifying information area).
Program-code specifying information is stored in the
program-code specifying information area, a method name is
stored in the method name area, a connection-destination
class name is stored in the connection-destination class
name area, and an address of the cell which is connected
next is stored in the pointer area. When there are plural
cells to be connected next, a plurality of addresses are
stored in the pointer area.
When the tree-structured data is generated based on
the sequence diagram data shown in Fig. 3, the tree-
structured data becomes as shown by 300 in Fig. 5, and the
tree-structured data 300 can be expressed as shown by
reference number 310.
The tree-structured data 300 includes cells 300a to
300d. The "program-code specifying information" is stored
in the program-code specifying information area in the cell
300a, "RecieveOrder" is stored in the method name area,
"Order" is stored in the connection-destination class name
area, and an "address of the cell 300b" is stored in the
pointer area.
"GenerateOrder" is stored in the method name area of
the cell 300b, "Receipt" is stored in the connection-
destination class name area, and "addresses of the cells
300c and 300d" are stored in the pointer area.
"GetCustomer" is stored in the method name area of the
cell 300c, and "Customer" is stored in the connection-
destination class name area. Since there is no subsequent
cell, data is not stored in the pointer area of the cell
300c.
"GetProduct" is stored in the method name area of the
cell 300d, and "Product" is stored in the connection-
destination class name area. Since there is no subsequent
cell, data is not stored in the pointer area of the cell
300d, similarly to the cell 300c.
The tree-structure-conversion processing unit 130a
generates a correspondence table representing
correspondence between respective class names and instance
names, based on the instance names and the class names
included in the instances in the sequence diagram data, and
stores a generated correspondence table 140c in the storing
unit 140.
Fig. 6 is one example of the correspondence table. As
shown in Fig. 6, the correspondence table 140c includes
class names and instance names.
Specifically, an instance name corresponding to the
class name "Order" is "a", an instance name corresponding
to the class name "Receipt" is "b", an instance name
corresponding to the class name "Product" is "c", and an
instance name corresponding to the class name "Customer" is
"d". The correspondence table is used by the program-
extraction processing unit 130c, which is described later.
Upon reception of sequence diagram data indicating a
specification of the program code to be newly generated
(hereinafter, "generated sequence diagram data") by reusing
the existing program code, the tree-structure-conversion
processing unit 130a converts the received generated
sequence diagram data to tree-structured data, sends the -
converted tree-structured data to the matching processing
unit 130b, and sends the generated sequence diagram data to
the program-extraction processing unit 130c.
Upon reception of the tree-structured data from the
tree-structure-conversion processing unit 130a, the
matching processing unit 130b retrieves tree-structured
data matching with the received tree-structured data from
the object tree-structured data 140b in the storing unit
140.
Specifically, as shown in Fig. 7, the matching
processing unit 130b analyzes the connection relationship
of cells included in the tree-structured data received from
the tree-structure-conversion processing unit 130a and the
tree-structured data obtained from the object tree-
structured data 140b, and allocates an identification
number to each cell in the respective tree-structured data.
The allocation procedure of the identification number
is such that an identification number "1" is allocated to a
top cell in the tree-structured data, and an identification
number "2" is allocated to a cell next to the cell
allocated with identification information "1".
When plural cells are connected in the same layer, the
identification number is allocated in order of recording of
addresses included in the pointer in the connection source
cell.
For example, with respect to the tree-structured data
300 shown in Fig. 5, identification numbers 1, 2, 3, and 4
are allocated to cells in order of cell 300a, cell 300b,
cell 300c, and cell 300d.
The matching processing unit 130b then determines,
sequentially, whether the method name and the connection-
destination class name are the same in the both tree-
structured data with respect to the cell having the same
identification number, and when the method name and the
connection-destination class name of all the cells are the
same, determines that the tree-structured data agree with
each other. The matching processing unit 130b then sends
the matching tree-structured data to the program-extraction
processing unit 130c.
For example, tree-structured data 360 corresponding to
a generation sequence diagram 350 shown in Fig. 8 matches
with the tree-structured data 300 shown in Fig. 5.
Therefore, the matching processing unit 130b sends the
tree-structured data 300 to the program-extraction
processing unit 130c.
The program-extraction processing unit 130c obtains
the tree-structured data from the matching processing unit
130b, and retrieves a program code corresponding to the
tree-structured data from the program code data 140a based
on the program-code specifying information included in the
obtained tree-structured data.
The program-extraction processing unit 130c then
replaces the instance name included in the program code by
a new instance name based on the detected program code and
the correspondence table 140c, and sends the replaced
program code to the output unit 120.
For example, upon reception of the tree-structured
data 300, the program-extraction processing unit 130c can
extract a program code 400b (shown in Fig. 9) corresponding
to the tree-structured data 300 from the program specifying
information included in the tree-structured data 300.
When the program-extraction processing unit 130c
retrieves the class corresponding to the instance "b" in
the program code 400b based on the correspondence table
140c, it is found that the class corresponding to the
instance "b" is "Receipt".
Accordingly, since the instance of the class "Receipt"
in the generated sequence diagram data shown in Fig. 8 is
"y", the program-extraction processing unit 130c converts
the instance in the program code 400a from "b" to "y", to
generate a new program code 400b.
That is, a program code corresponding to the sequence
diagram can be generated only by specifying a sequence
diagram of the specification of the program code to be
newly generated, without the need to generate a program
code from the initial stage.
Although detailed explanations are omitted in the
present embodiment, when the number of identification
numbers allocated to the tree-structured data received from
the tree-structure-conversion processing unit 130a does not
agree with the number of identification numbers allocated
to the tree-structured data obtained from the object tree-
structured data 140b, it is determined that the both tree-
structured data do not match with each other.
A preparation process in which the tree-structure-
conversion processing unit 130a makes the storing unit 140
store the tree-structured data and the program code
corresponding to the tree-structured data beforehand is
explained. Fig. 10 is a flowchart of a process procedure
in the preparation process.
As shown in Fig. 10, the input receiving unit 110
reads the program code and the sequence diagram (step S101),
and sends the program code and the sequence diagram data to
the tree-structure-conversion processing unit 130a (step
S102).
The tree-structure-conversion processing unit 130a
performs tree-structure-conversion process (step S103) to
generate a correspondence table (step S104) to make the
storing unit 140 store the correspondence table (step S105).
The tree-structure-conversion processing unit 130a
makes the storing unit 140 store the program code (step
S106), adds the program-code specifying information to the
tree-structured data (step S107), so that the tree-
structured data is stored in the storing unit 140 (step
S108).
The tree-structure-conversion process at step S103 in
Fig. 10 is explained below. Fig. 11 is a flowchart of a
process procedure in the tree-structure-conversion process.
As shown Fig. 11, the tree-structure-conversion processing
unit 130a searches the leftmost and uppermost method arrow
in the sequence diagram (step S201) to generate a cell
(step S202), stores the method name and the connection-
destination class name in the cell (step S203), and records
the connection source class name of the arrow (step S204).
(Although omitted in the above explanation, the tree-
structure-conversion processing unit 130a stores the
connection source class name of the searched arrow.)
The tree-structure-conversion processing unit 130a
searches the next downward closest arrow (step S205),
determines whether there is such an arrow (step S206), and
when there is no such arrow (step S206, No), finishes the
tree-structure-conversion process.
On the other hand, when there is such an arrow (step
S206, Yes), the tree-structure-conversion processing unit
130a generates a cell (step S207), and stores a method name
and a connection-destination class name in the cell (step
S208), to determine whether a connection source class name
relating to an arrow immediately before is the same as the
connection source class name of the current arrow (step
S209).
When the connection source class name relating to the
arrow immediately before is not the same as the connection
source class name of the current arrow (step S209, No), the
tree-structure-conversion processing unit 130a stores the
address of the current cell in the pointer of the cell
generated immediately before (step S210), updates the
connection source class name of the recorded arrow to the
connection source class name of the current arrow (step
S211), and proceeds to step S205.
On the other hand, when the connection source class
name relating to the arrow immediately before is the same
as the connection source class name relating to the current
arrow (step S209, Yes), the tree-structure-conversion
processing unit 130a adds the address of the current cell
to the pointer of the calling cell (step S212), and
proceeds to step S211.
A program generation process for generating a program
code based on a sequence diagram of the program code to be
newly generated is explained next. Fig. 12 is a flowchart
of a process procedure in the program generation process.
As shown in Fig. 12, the input receiving unit 110 reads the
sequence diagram (step S301) and sends the sequence diagram
data to the tree-structure-conversion processing unit 130a
(step S302). The tree-structure-conversion processing unit
130a performs tree-structure-conversion process (step S303)
and sends the tree-structured data to the matching
processing unit 130b (step S304).
The matching processing unit 130c performs a matching
process (step S305), determines whether there as matching
tree-structured data (step S306), and when there is no
matching tree-structured data (step S306, No), finishes the
process.
On the other hand, when there is matching tree-
structured data (step S306, Yes), the matching processing
unit 130b sends the matching tree-structured data to the
program-extraction processing unit 130c (step S307). The
program-extraction processing unit 130c retrieves a program
code corresponding to the matching tree-structured data
(step S308), replaces the instance name of the program code
based on the correspondence table (step S309), and sends
the program code to the output unit 120 (step S310). The
output unit 120 outputs the program code (step S311).
Since the tree-structure-conversion process at step
S303 in Fig. 12 is the same as that shown in Fig. 11, the
explanation thereof is omitted.
The matching process at step S305 in Fig. 12 is
explained next. Fig. 13 is a flowchart of a process
procedure in the matching process. As shown in Fig. 13,
the matching processing unit 130b obtains the tree-
structured data from the object tree-structured data 140b
(step S401), allocates an identification number to the
tree-structured data (step S402), and performs a cell
selection process (step S403), to determine whether the
respective method names and connection-destination class
names are the same between the both tree-structured data
(step S404).
When the respective method names and connection-
destination class names are the same (step S404, Yes), the
matching processing unit determines whether all the cells
included in the tree-structured data have been selected
(step S405). When all the cells included in the tree-
structured data have not been selected (step S405, No),- the
process proceeds to step S403. When all the cells included
in the tree-structured data have been selected (step S405,
Yes), the matching processing unit determines that there is
matching tree-structured data (step S406).
On the other hand, when the respective method names
and the connection-destination class names are not the same
(step S404, No), the matching processing unit determines
whether matching has been performed with respect to all the
tree-structured data (step S407). When matching has not
yet been performed with respect to all the tree-structured
data (step S407, No), the matching processing unit obtains
the next tree-structured data from the object tree-
structured data 140b (step S408), and proceeds to step S402.
On the other hand, when matching has been performed
with respect to all the tree-structured data (step S407,
Yes), the matching processing unit determines that there is
no matching tree-structured data (step S409).
The cell selection process at step S403 in Fig. 13 is
explained next. Fig. 14 is a flowchart of a process
procedure in the cell selection process. As shown in Fig.
14, the matching processing unit 130b determines whether a
cell included in the tree-structured data received from the
tree-structure-conversion processing unit 130a and a cell
included in the tree-structured data obtained from the
object tree-structured data 140b are to be selected for the
first time (step S501). When the cells are to be selected
for the first time (step S501, Yes), the matching
processing unit 130b respectively selects cells
corresponding to the identification number "1" from the
both data (step S502).
On the other hand, when it is not the first time to
select the. cells (step S501, No), the matching processing
unit 130b determines whether the tree-structured data has
been newly obtained from the object tree-structured data
140b (step S503), and when the tree-structured data has
been newly obtained from the object tree-structured data
140b (step S503, Yes), the matching processing unit 130b
converts the old tree-structured data previously obtained
from the object tree-structured data 140b to the newly
obtained tree-structured data (step S504), and proceeds to
step S502.
On the other hand, when the tree-structured data has
not been newly obtained from the object tree-structured
data (step S503, No), the matching processing unit 130b
respectively selects cells corresponding to an
identification number next to the previously selected
identification number (step S505).
In the source-code-generation supporting program
according to the present embodiment, the tree-structure-
conversion processing unit 130a generates the tree-
structured data based on the generated sequence diagram
data, and the matching processing unit 130b retrieves tree-
structured data matching with the generated tree-structured
data from the object tree-structured data 140b. The
program-extraction processing unit 130c then obtains a
corresponding existing program code from the program-code
specifying information in the matching tree-structured data,
and replaces the instance name in the obtained program code
by an instance name corresponding to the generated sequence
diagram data. Accordingly, it is not necessary to develop
the program code from scratch, and the program code can be
generated only by specifying the sequence diagram. As a
result, productivity of the program code can be improved.
Furthermore, since the program code corresponding to
the sequence diagram can be automatically generated only by
specifying the sequence diagram, even users having no
knowledge of script language can easily generate the
program code.
In the present embodiment, the source-code-generation
supporting apparatus 100 has been explained. However, by
realizing the configuration of the source-code-generation
supporting apparatus 100 by software, a source-code-
generation supporting program having the same function can
be obtained. A computer system that executes the source-
code-generation supporting program is explained below.
Fig. 15 depicts the computer system that executes the
source-code-generation supporting program according to the
present embodiment. As shown in Fig. 15, a computer system
500 includes a main body unit 501, a display 502 that
displays information on a display screen 502a according to
an instruction from the main body unit 501, a keyboard 503
for inputting various types of information to the computer
system 500, a mouse 504 for specifying an optional position
on the display screen 502a of the display 502, a LAN
interface connected to a, LAN 506 or a wide area network
(WAN), and a modem 505 connected to a public line 507. The
LAN 506 connects between the computer system 500 and other
computer systems (PC) 511, a server 512, a printer 513, and
the like.
Fig. 16 is a functional block diagram of a
configuration of the main body unit 501 shown in Fig. 15.
As shown in Fig. 16, the main body unit 501 includes a CPU
521, a RAM 522, a ROM 523, a hard disk drive (HDD) 524, a
CD-ROM drive 525, an FD drive 526, an I/O interface 527,
and a LAN interface 528.
The source-code-generation supporting program executed
in the computer system 500 is stored in a portable storage
medium such as a floppy disk (FD) 508, a CD-ROM 509, a DVD
disk, a magneto-optical disk, and an IC card,; read out from
the storage medium, and installed in the computer system
500. The installed motion picture distribution program is
stored in the HDD 524, and executed by the CPU 521, using
the RAM 522, the ROM 523, and the like.
As described above, according to the present invention,
the tree-structured data is generated based on the sequence
diagram indicating the specification of the source code to
be newly generated, tree-structured data matching with the
generated tree-structured data is retrieved from the
storing unit that stores at least existing source codes and
tree-structured data corresponding to the existing source
codes, and the source code corresponding to the matching
tree-structured data is obtained from the storing unit.
Accordingly, it is not necessary to develop the source code
from scratch, and a desired source code can be generated
only by specifying the sequence diagram. As a result, the
burden on the user can be eliminated, and the efficiency of
program development can be improved.
INDUSTRIAL APPLICABILITY
The source-code-generation supporting program and the
source-code-generation supporting method according to the
present invention are suitable for a program development
system based on the object oriented techniques in which it
is necessary to generate a source code efficiently by using
existing source codes.
WE CLAIM
1. A computer apparatus (100) for supporting creation of a source code based
on object orientation, comprising :
a creating unit (130a) that creates first tree-structured data based on a first
sequence diagram indicating a specification of an existing program code and
second tree-structured data based on a second sequence diagram indicating
a specification of a new program code to be created and a correspondence
table indication corresponding relationship between an instance name and a
class name in an instance in first sequence diagram, the sequence diagram
having the instance and a method, the instance having the instance name
and the class name;
a storing unit (140) that stores the first tree-structure data and the existing
program code relatively to each other and the correspondence table;
characterized by comprising:
a retrieving unit (130b) that retrieves tree-structured data matching with the
second tree-structured data from the storing unit; and
an acquiring unit (130c) that acquires a program code corresponding to the
tree-structured data retrieved by the retrieving unit; and
a generating unit (130) that generates the new program code by replacing an
instance name in the program code acquired with a new instance name
based on the correspondence table.
2. The computer apparatus as claimed in claim 1, further comprising :
a converting unit (130) that converts the instance in the program code
acquired by the acquiring unit (130c) into the instance corresponding to the
sequence diagram.
3. The computer apparatus as clamed in claim 1, wherein when the creating
unit (130a) creates the first tree-structured data, the creating unit (130a)
extracts a connection relationship between the instance and a method in the
first sequence diagram; and creates the first tree-structured data having the
first method-sequence information based on the connection relationship.
4. The computer apparatus as claimed in claim 3, wherein the retrieving unit
(130b) retrieves the tree-structured data having second method-sequence
information equivalent to the first method-sequence information from the
storing unit (140).
5. A method in a computer apparatus as claimed in any of claims 1 to 4, for
supporting creation of a source code based on object orientation.

The invention relates to a tree-structure conversion processing section (130a)
generates tree-structure data according to generation sequence diagram data. A
matching processing section (130b) searches tree-structure data matched with
the generated tree-structure data from object tree-structure data (140b). A
program extraction processing section (130c) acquires a corresponding existing
program code from information specifying the program code of the matched
tree-structure data and replaces an instance name of the acquired program code
with an instance name corresponding to the generation sequence diagram data.