JP2001296996A - Automatic generating device of component and expressing method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To obtain the automatic generating device of a component by which a once-developed software component can be reused at a source level. SOLUTION: By using data held in the respective files of an environment independent component (2), an environment dependent component (3), an application environment (4), a component for a specific environment (5), a basic description rule for the specific environment (6) and a meta-program for customizing (7), the operation of a program automatically generating processing is controlled by a program automatically generating engine 1 to construct a prescribed component target environment source file 8 for operating a once-generated component in a new environment. Concerning environment independent component definition, reusing is possible as it is and concerning the environment dependent component, the whole application can be generated by only writing the part in addition in the case it corresponds to a new programming language environment.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an automatic component generating apparatus and an expression method, and more particularly to an automatic component generating apparatus and an expression method for reusing a component once developed.

[0002]

2. Description of the Related Art Conventionally, an automatic component generation apparatus and an expression method are intended, for example, to reuse a component created once in a different environment, and to that end, it is applied to the technical field of an automatic program generation apparatus. .

In the conventional software development, first, each component constituting a system is composed of any programming language environment (platform, OS, language, mounting method, communication method, black box component to be used, etc.).
Then, the source code of each component is manually created in the OS, the language, and the mounting method. Further, in order to reuse a code once created, an automatic program generation device or a conversion device may be used.

[0004]

However, in the above-mentioned prior art, it is very difficult and impractical to make the device itself compatible with many programming language environments, and there are the following problems.

[0005] First, it is difficult to reuse components that have been developed once. The reason is that if you want to run a software component once developed in another environment, you have to manually rewrite the source code for almost all parts. Also,
Without a cost that is equal to or higher than the initial cost, a software component that operates in another environment with the same function cannot be realized.

Second, when components are automatically generated from the same source code using a program automatic generation device to automatically generate source codes corresponding to different programming language environments, the program automatic generation device itself is adapted to many programming language environments. Is very costly and impractical. The reason is,
The automatic program generation device itself depends on a specific programming language environment, and it is difficult to reuse the automatic program generation device itself in order to cope with another programming language environment.

The present invention reuses software components that have been developed once at the source level, and uses the components in other environments, for example, other platforms, other OSs.
It is an object of the present invention to provide a component automatic generation apparatus and an expression method capable of reducing costs when operating by using S, another language, another implementation method, another communication method, and another black box component.

More specifically, the present invention provides, as a means, a component expression method for separately creating a component of business logic which does not originally depend on a programming language environment and a component which depends on a programming language environment. It is an object of the present invention to provide an automatic program generation device for automatically generating source codes of components in a plurality of target programming language environments from a target program language environment.

[0009]

To achieve the above object, an automatic component generation apparatus according to the present invention includes an environment-independent component definition file for holding environment-independent component definitions, and an environment-independent component definition file. An environment-dependent component definition file that holds the definition, an application environment definition file that holds the application environment definition, a component definition template file for the specific environment that holds the component definition template for the specific environment, and a basic description rule for the specific environment A basic description rule file for a specific environment to be created, a customization metaprogram file that holds a customization metaprogram, and a program that controls the operation of the program automatic generation process using the data held in each file. Is configured to have a ram automatic generation system engines, it is characterized by constructing a predetermined component target environment sources for operating the components created once the new environment.

[0010] The program automatic generating device engine includes an application generating means for generating a source code for a target environment of each component as internal data, an API corresponding to a target programming language environment, and the contents of the API as internal data. It is preferable to include a component generation unit that generates the contents of the API, an API content generation unit that performs settings for generating the contents of the API and generates the internal data, and a BODY generation unit that generates an image of the generated source code in the internal data.

Further, the application generation means reads the environment-independent component definition file, the environment-dependent component definition file, and the application environment definition file, and generates source code for a target environment of each component. For the component for which code is generated, the component definition template for the specific environment corresponding to this component is read and reflected in the internal data, API content generation means is applied to each abstract API of the component, and the target programming language environment is supported. Generated API and its contents in internal data,
Generates the code for the higher-level component necessary for the higher-level component to use the component in the internal data, and the core part of the automatic program generation device does not depend on the specific programming language environment, and depends on the specific programming language environment The part may be added to the automatic program generation device.

[0012] The above-mentioned API content generation means performs settings for generating the API and the contents corresponding to the target programming language environment, generates internal data by applying the BODY generation means, and executes the BODY generation means. Target A
If the BODY that defines the contents of the function of the component in units of PI is dependent on the programming language environment, select the BODY that matches the specified programming language environment, execute the metaprogram, and execute B
If ODY is independent of the programming language environment, the part of the abstract API used is
It is preferable that the BODY generating means is recursively executed repeatedly by replacing with ODY to generate internal data.

According to a seventh aspect of the present invention, there is provided an automatic component generation method, comprising: an environment-independent component definition; an environment-dependent component definition; an application environment definition; a component definition template for a specific environment;
When the basic description rules for the specific environment and the metaprogram for customization are retained, the operation of the automatic program generation process is controlled using the retained data, and the component created once is operated in the new environment. Without changing the environment-independent components involved,
It is characterized by adding a description corresponding to this environment-dependent component and a new programming language environment to be added later to the automatic program generation device, and automatically generating a source file of a new programming language environment for an existing component.

The above environment-independent component means that each BODY uses only an abstract API, and the environment-dependent component means what native language in a specific programming language environment is included in each BODY. This is a description of whether to write code. In the automatic program generation process, the settings for generating the contents of the API are generated and generated as internal data, and this API corresponding to the target programming language environment and the contents of the API are generated. May be generated as internal data, a source code for a target environment of each component may be generated as the internal data, and an image of the generated source code may be generated as the internal data.

[0015]

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing an embodiment of an automatic component generating apparatus and an expression method according to the present invention; Referring to FIGS. 1 to 21, there is shown an embodiment of an automatic component generation apparatus and an expression method according to the present invention.

FIG. 1 is a block diagram showing an example of the configuration of an automatic component generation apparatus according to the present embodiment, and FIG. 2 is a block diagram showing an example of the configuration of an automatic program generation engine 1 in FIG.

Referring to FIG. 1, the component automatic generation apparatus according to the first embodiment of the present invention includes a file group 2 for storing environment-independent component definitions.
2, the same file group 3 holding environment-dependent component definitions, the same file group 4 holding application environment definitions, and the same file group 5 holding specific environment component definition templates, etc.・ 5, and the same file group 6 which holds basic description rules for specific environment,
6, a file group 7 for holding a customizing meta-program, a program automatic generation device engine 1 which is a core part of the program automatic generation device and controls the processing operation of the program automatic generation process. Consists of The component target environment source is constructed by the component automatic generation apparatus of this configuration, and is stored in the same file group 8,.

Referring to FIG. 2, the automatic program generation device engine 1 includes an application generation unit 11, a component generation unit 12, an API content generation unit 13,
ODY generation means 14 is provided. Each of these means operates as follows. The API (Appl
ication Programming Interface) is generally
A function set for using basic software such as an OS and a DBMS (database management system) from a program, and a function set of a component used when creating an application program.

The application generating means 11 reads the component definition files 2 and 3 which are environment independent and dependent, and the environment definition file 4 and makes them internal data, applies the component generating means 12, and generates the data by the component generating means 12. From the internal data representing the generated source code, actual source code 8,... 8 for the target environment of each component is generated.

The component generation means 12 reads the specific environment component definition template 5 corresponding to the component for which the source code 8,..., 8 is actually generated, reflects the component definition in the internal data, and The API content generation means 13 is applied to each abstract API to generate an API corresponding to the target programming language environment and its contents as internal data. Also, a code for a higher-level component necessary when the higher-level component uses the component is generated in internal data.

The API content generation means 13 makes settings for generating APIs corresponding to the target programming language environment and the contents thereof, and applies the BODY generation means 14 to generate these into internal data.

If the BODY depends on the programming language environment, the BODY generating means 14 selects a BODY that matches the designated programming language environment and executes the metaprogram. If so, the abstract AP used
The I portion is replaced by the abstract API BODY, and the BODY generating means 14 is repeatedly executed recursively to actually generate an image of the generated source code in the internal data.

The metaprogram is an abstract API.
When the source code is automatically generated from the description of the component expressed by the following expression and BODY, a part of the automatic generation method is cut out in units of components or abstract APIs, and the change is made to the core part of the automatic generation device. It changes the method of automatic generation without adding it so that it can be customized.

The environment-independent component is defined by each B
ODY means that only the abstract API is used. In addition, the environment-dependent component refers to each BOD
In Y, what means what native code is written in a specific programming language environment is described.

(Operation) Next, referring to the block diagrams of FIGS. 1 and 2 and the flowcharts of FIGS. 3, 4, 5, 6, 7, and 8, an example of the entire operation will be described in detail. explain.

First, the operation procedure of the application generating means 11 will be described with reference to FIG. The definition data held in the component definition file groups 2 and 3 and the environment definition held in the application environment definition file 4 are read, and internal data is created (step A1). Next, the component generation unit 12 is applied to the top component that is the top component in the application environment definition file 4 (step A2). Further, for each component that is not a macro, a target source file is created from the internal data (step A3).

Next, the operation procedure of the component generation means 12 will be described with reference to FIG. Is the component generation means 12 a component being created or a component already created?
(Check J1), is it a macro component? (Check J2), is there a part that matches the environment in the template of the component currently being created? (Check J
Execute 3).

After passing these checks J1 to J3,
The component definition template file 5 for the specific environment followed by the component is read, and the part of the template that matches the programming language environment specified in the application environment definition file 4 is reflected in the internal data (step B1).
Next, the component generation unit 12 is recursively applied to all components used by the component (step B2). Next, the API content generation unit 13 is applied to all the abstract APIs of the component (step B3). The component meta-program attached to the component is executed (step B4).

Next, the operation procedure of the API content generation means 13 will be described with reference to FIG. The API content generation means 13 describes in the internal data that the actual API of the abstract API of interest and the content thereof are to be generated (step C1).
A of the abstract API in a specific programming language environment
A PI and settings for generating its contents are made. Then, the BODY generation means 1 for the BODY of the abstract API
4 is applied (step C2).

Next, referring to FIG.
The operation procedure of No. 4 will be described. In the BODY generating means 14,
First, it is checked whether the BODY under consideration depends on the programming language environment or not (K1). If the BODY depends on the programming language environment (the native code of how to write in each programming language environment is written) (K2 / YES), BODY
Of the programming language environment specified by the application environment definition from the
DY (D1), and then A of the replaced BODY
The PI metaprogram is executed, and a part of the generated code is created in the internal data (step D2).

In the BODY generating means 14, if the BODY of interest does not depend on the programming language environment (if BODY is written only with an abstract API) (K1 / NO), the BODY Is replaced with the BODY of the abstract API used by the BODY, and the BODY generating means is recursively applied to this (step D3).
The I metaprogram is executed, thereby creating a part of the generated code in the internal data (step D4).

According to the above procedure, the BODY generating means 1
4 is recursively applied, and the BODY generating means 14 is recursively applied from the API metaprogram, whereby the generated code is gradually generated in the internal data. The association of arguments and APIs is actually performed in the API metaprogram. When the place to return from the metaprogram to be executed is the API content generation unit 13, the metaprogram generates an API in the target programming language environment.

Next, when returning from the API content generation means 13 to the component generation means 12, the component metaprogram attached to the component is executed (step B4 in FIG. 4).

This component metaprogram generates, in internal data, a code for a higher-level component necessary when the higher-level component uses the component. Finally, when returning from the component generation means 12 to the application generation means 11, an image of a target source of each component for generating a source is completed in internal data, and the source code of each component in the target programming language environment is obtained from the internal data. Generate a file (Step A in FIG. 3)
3).

When the created application is operated in a new environment, a group of environment-dependent component definition files 3,..., And a group of component definition template files 5 for a specific environment to be added to the automatic program generator engine 1 are provided. .5, and a specific environment basic description rule file group 6,... 6, and a customization metaprogram file group 7,. However, the description of the environment-independent component definition file group 2,..., 2 is not changed. Under these conditions,
Generate target environment source files 8,... 8 for the components in the new programming language environment.

Next, effects of the present embodiment will be described. In the present embodiment, regarding the definition of components, the input to the automatic program generation engine 1 is configured so that the environment-independent component definition file 2 and the environment-dependent component definition file 3 are clearly separated. For this reason, if the automatic program generation device supports the new programming language environment and creates an application environment definition, the environment-independent component definition file 2 can be reused as it is.
Regarding environment-independent components, the description part in the new programming language environment is clear,
If the automatic program generator engine 1 is compatible with a new programming language environment, the entire application can be created simply by adding that part.

In the present embodiment, when the automatic program generation apparatus is adapted to a different programming language environment, a part for automatically generating a different programming language environment in the automatic generation is specified as a specific environment component definition template group 5. The basic description rule file group 6 for environment and the metaprogram group 7 for customization are configured to be added to the automatic program generation engine 1 afterwards. Therefore, the automatic program generation device engine 1 can be made independent of the programming language environment. Thereby, the automatic generation function in a new programming language environment can be realized without affecting the automatic generation function in a programming language environment already supported by the automatic program generation device engine 1.

Next, the operation of this embodiment will be described with reference to specific examples. FIG. 8 is a flowchart showing the operation of the default API metaprogram, and shows the flow of the operation of an API metaprogram (a type of customization metaprogram) prepared by default. FIG.
Shows the operation flow of the component metaprogram (a type of customization metaprogram) prepared by default. 9 and 10 show configuration examples of the environment-independent component definition file 2.

FIGS. 11 and 12 show examples of the configuration of the environment-dependent component definition file 3. FIG. FIG. 13 is a configuration example of the application environment definition file 4. FIG.
FIG. 15 is a configuration example of the component definition template file 5 for a specific environment, which is added to the automatic program generation device engine 1. FIG. 16 shows an example of the configuration of the basic description rule file 6 for a specific environment attached to the automatic program generation engine 1.

First, when step A1 of the application generating means 11 is executed, the environment-independent component definition (MyWindow) in FIG. 10 becomes internal data as shown in FIG. 17, and the environment-dependent component definition in FIG. The file (MyButton) 3 becomes internal data as shown in FIG. 18 (step A1 in FIG. 3).

Next, in step B1 in the component generation means 12, the specific environment template definition (FIG. 14 and FIG. 15) of each component is designated by the programming language environment (application environment definition of each component, and FIG. 13). Then, a portion corresponding to the component programming language environment is designated as Java) is extracted, and this is reflected in internal data representing a generated code generated by executing step A1 of the application generating means 11 (step B1 in FIG. 4). ) And internal data as shown in FIG.

This has generation source information corresponding to the environment-independent component definitions (MyApp, MyWindow) in FIGS. 9 and 10 and the environment-dependent component definition (MyButton) in FIG. Some are left undefined or modified.

Next, in step B3 of the component generation means 12, the component (MyWi
ndow) Abstract API of the component
The API content generation means 13 is applied to

First, As for the first API of the component (MyWindow) defined in FIG. 10, “Create a child part of $ this with $ parent as the parent.” As a result of applying the API content generation unit 13, how the internal data is changed I will explain. The API content generation means 13 sets the abstract API in a specific programming language environment and a setting for generating the content (step C in FIG. 5).
1) BOD for BODY part of the abstract API
The Y generation means 14 is applied (Step C2 in FIG. 5).

The BODY part of interest is “MyButton $ bt
n is not dependent on the programming language environment of "Create parent with $ parent", so replace this BODY with the BODY of abstract API "Create MyButton $ btn with parent of $ parent". The BODY generating means 14 is applied again (step D in FIG. 6).
3). The BOD being watched in the BODY generating means 14
Y is the abstract API “$ this
Is the BODY of "Create parent with $ parent". Since this depends on the programming language environment, the specified programming language environment (Java)
(The part enclosed by env Java in FIG. 11) (step D1 in FIG. 6).

Next, the BODY metaprogram (the default API metaprogram shown in FIG. 8) is executed (step D2 in FIG. 6). By this metaprogram execution, the BO that is passed by the arguments $ this and $ parent
Applying BODY generation means 14 to DY to obtain how the arguments are represented in the target programming language environment, and furthermore, source 1 and source 2 in FIG.
Into the internal data representing the generated code. However, at this stage, the association with the higher-level component (MyWindow) has not been made yet, and an undefined portion is included.

When returning from the BODY generating means 14, the process returns after step D3 in FIG.
DY metaprogram (default AP shown in FIG. 8)
I metaprogram) (step D in FIG. 6)
4). According to this metaprogram, the internal data of the generated code associates the source 1 and the source 2 with the higher-level component (MyWindow) using the source, and the internal data representing the generated code for the component MyWindow is as shown in FIG. From FIG. 20 to FIG. The shaded portion is the changed portion.

The components defined in FIG. 10 (MyWi
The same is repeated for the second API and the third API of (ndow), and the internal data representing the generated code related to the component MyWindow changes from that shown in FIG. 20 to that shown in FIG. The shaded portion is the changed portion. At this point, the component MyWi
There is no undefined part from the internal data representing the generated code of ndow.

When returning from the component generation means 12 for the component MyWindow, next, step A3 of the component generation means 12 is performed for the component MyApp, and internal data representing the generation source of MyApp is generated in the same manner as in the case of MyWindow. . With MyApp,
In the BODY of the first abstract API "main", "MyWi
ndow $ wnd is created, which is defined in the basic description rules for a specific environment. In the method of the present invention, this is defined as a virtual (macro) environment-dependent component definition. Finally, the internal data representing the generated code for MyWindow is created in the same way.

Returning from the component generating means 12 for the top component MyApp,
Step A3 of the application generating means is executed, and for each component, a source file in a target programming language environment is created from internal data.
In the case of component MyWindow, My in Fig. 21
The actual source code file is generated by sequentially tracing the nodes of the effective graph without loops from the node called Window.java and outputting the source fragments to a file in order.

In the application environment definition of FIG.
Although the programming language environment is designated as "Java (registered trademark)", when this application is operated in a different programming language environment by changing this to "C ++, Window (registered trademark) s", FIGS.
"C ++, Windows" in the environment-dependent component definition 2
In the case of, a description of how to write is added, and FIG.
By adding the description for “C ++, Windows” to the component definition template for the specific environment in FIG. 15, and by adding the code for that case if the default metaprogram does not support “C ++, Windows”. “C ++, Window” for each component that composes the application
Automatically generate source files in the s ”programming language environment.

(Effect) The first effect is that the environment-independent component definition can be reused as it is even if the environment in which the component operates changes. The reason is to generate a source corresponding to a programming language environment that operates the automatic program generation device, and to generate a target source in a different programming language environment without changing the environment-independent component definition.

The second effect is that when the component is moved in another environment, the correction becomes easy. The reason for this is that there is no need to change the parts already described for environment-dependent components, and it is clear where they need to be added, and it is sufficient to add them. Also, this is because the cost of making the automatic program generation device itself compatible with different programming language environments is lower than before.

A third effect is that the automatic program generation apparatus can be adapted to many programming language environments at a lower cost as compared with the related art. The reason is,
The automatic program generator engine does not depend on a specific programming language environment. The parts that depend on the programming language environment include component definition templates for specific environments, basic description rules for specific environments, and meta-data for customization. This is because roles can be separated as programs and created later.

According to the present invention, a software component developed once is reused at a source level, and the component is reused in another environment (another platform, another OS, another language, another mounting method, another communication method, another communication method, or the like). The use of a black box component) can provide a configuration that can reduce costs.

As means therefor, a component expression method in which a component of business logic which does not originally depend on a programming language environment and a portion which depends on a programming language environment are separately created, and a plurality of target programming language environments are created therefrom. It is an object of the present invention to provide an automatic program generation device for automatically generating a source code of a component in a simple form.

The representation format of the component according to the present invention has two features. First, the definition of a component is represented by a set of three combinations of an abstract API, BODY, and a metaprogram. The second is to allow the existence of virtual (macro) components that exist logically but do not create actual instances.

In the component expression method of the present invention, the definition of a component that does not depend on the programming language environment is a component definition in which the contents of each abstract API are described in BODY using only the abstract API. The definition of a component to be written is a definition of a component that describes how to write the contents of each abstract API in which programming language environment. The BODY of the component definition that depends on the programming language environment almost describes the native code in the target programming language environment, and the part that needs to be modified by associating variables is the meta program that modifies the native code written in the BODY. Describe.

An automatic program generation apparatus for automatically generating a source code for a target programming language environment from the definition of these components is provided. For a component definition independent of the programming language environment, even if the programming language environment changes, the target There is no need to rewrite the code for a programming language environment, and the reusability of environment-independent components is improved. For components that depend on the programming language environment, where the programming language environment changes, the places to be added are clear, and it is not necessary to rewrite the parts already written.

In the component representation method of the present invention, by making the environment-dependent component a virtual component having no substance, the abstract API of the component can represent not only methods and events but also expressions and statements. As a result, basic description rules in each programming language environment can be treated as environment-dependent components. This eliminates the need to include basic description rules in each programming language environment in the core of the automatic program generation device, and makes the core of the automatic program generation device independent of the programming language environment.

In each programming language environment, by automatically adding a part defining what kind of structure is created, an automatic generation function in a new programming language environment can be implemented in a previously created programming language environment. It can be added without affecting the automatic generation function. In this way, the cost for realizing an automatic program generation device corresponding to different programming language environments is reduced.

The above embodiment is an example of a preferred embodiment of the present invention. However, it is not limited to this.
Various modifications can be made without departing from the spirit of the present invention.

[0063]

As is apparent from the above description, the automatic component generation apparatus and method of the present invention provide an environment-independent component definition, an environment-dependent component definition, an application environment definition, and a component definition for a specific environment. Holds templates, basic description rules for specific environments, and metaprograms for customization, controls the operation of program automatic generation processing using the stored data, and allows components created once to be used in a new environment. When operating, do not change the environment-independent components involved, add a description corresponding to this environment-dependent component and a new programming language environment to be added to the automatic program generation device, and add a new programming language for the existing components Environment source files Generated.

For this reason, if the automatic program generation device side supports a new programming language environment and creates an application environment definition, the environment-independent component definition can be reused as it is. Regarding environment-dependent components, the description part in the new programming language environment is clear, and if the automatic program generation device corresponds to the new programming language environment,
By simply adding that part, you can create the entire application.

Further, the automatic program generation device engine can be made independent of the programming language environment, whereby the automatic generation function in the programming language environment already supported by the automatic program generation device is not affected. An automatic generation function in a new programming language environment can be realized.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration example of an embodiment of an automatic component generation device and an expression method according to the present invention.

FIG. 2 is a block diagram showing a configuration example of an automatic program generation engine in FIG. 1;

FIG. 3 is a flowchart illustrating an operation example of an application generation unit.

FIG. 4 is a flowchart illustrating an operation example of a component generation unit.

FIG. 5 is a flowchart showing an operation example of an API content generation unit.

FIG. 6 is a flowchart illustrating an example of a processing procedure in a BODY generation unit.

FIG. 7 is a flowchart showing the operation of a default component metaprogram.

FIG. 8 is a flowchart showing the operation of a default API metaprogram.

FIG. 9 shows a configuration example of an environment-independent component definition (MyApp).

[Figure 10] Environment-independent component definition (MyWindow)
Is shown.

FIG. 11 shows a configuration example of an environment-dependent component definition (MyButton).

FIG. 12 illustrates a configuration example of an environment-dependent component definition (MyDialog).

FIG. 13 shows a configuration example of an application environment definition.

FIG. 14 illustrates a configuration example of a component definition template (App) for a specific environment.

FIG. 15 illustrates a configuration example of a component definition template for a specific environment (MainWindow).

FIG. 16 shows a basic description rule for a specific environment (DefaultRule).
3) shows a configuration example.

FIG. 17 illustrates a configuration example of internal data (MyWindow) of a component definition after reading [image].

FIG. 18 illustrates a configuration example of internal data (MyButton) of a component definition after reading.

FIG. 19: MyAp is added to the read application environment definition
An example of the configuration of internal data after applying the component definition template for p and MyWindow is shown.

FIG. 20 shows a configuration example of internal data after generation of API-1 of MyWindow for the MyWindow portion.

FIG. 21 shows a configuration example of internal data after API-2 and API-3 are generated in MyWindow for the MyWindow part.

[Explanation of symbols]

1 Automatic Program Generator Engine 2 Environment-independent component definition file 3 Environment-dependent component definition file 4 Application environment definition file 5 Component definition template file for specific environment 6 Basic description rule file for specific environment 7 Metaprogram file for customization 8 Component target Environment source file 11 Application generation means 12 Component generation means 13 API content generation means 14 BODY generation means

Claims (9)

[Claims] 1. An environment-independent component definition file that holds an environment-independent component definition, an environment-dependent component definition file that holds an environment-dependent component definition, an application environment definition file that holds an application environment definition, A component definition template file for a specific environment holding a component definition template, a basic description rule file for a specific environment holding a basic description rule for a specific environment, a customization metaprogram file holding a customization metaprogram, A program automatic generation device engine for controlling the operation of the automatic program generation process using the data held in each file, and the components once created are stored in a new environment. Automatic generation system components, characterized in that to construct a given component target environment sources of operating. 2. The program automatic generation device engine includes: an application generation unit that generates, as internal data, a source code for a target environment of each component; an API corresponding to a target programming language environment; and contents of the API as internal data. Component generating means for generating, API content generating means for performing settings for generating the contents of the API and generating internal data, and B for generating an image of the generated source code as internal data
2. The automatic component generation apparatus according to claim 1, comprising: an ODY generation unit. 3. The application generating means reads an environment-independent component definition file, an environment-dependent component definition file, and an application environment definition file, and generates source code for a target environment of each component. An automatic component generation device according to claim 2. 4. The component generation unit reads a component definition template for a specific environment corresponding to the component for which a source code is generated, reflects the template on internal data, AP
Applying the I content generation means, generating an API corresponding to the target programming language environment and its contents in internal data, generating a code for the upper component necessary for a higher component to use the component in the internal data, 3. The automatic component generation device according to claim 2, wherein a core portion of the automatic generation device does not depend on a specific programming language environment, and a portion that depends on the specific programming language environment is added to the program automatic generation device. Generator. 5. The API content generation unit includes: an API corresponding to a target programming language environment.
3. The automatic component generation apparatus according to claim 2, wherein a setting for generating I and contents is performed, and the internal data is generated by applying the BODY generation unit. 4. 6. The BODY generating means, if the BODY that defines the content of the function of the component in a unit extracted by the abstract API depends on a programming language environment, matches the specified programming language environment. And executing the metaprogram. If the BODY is independent of the programming language environment, replace the part of the abstract API used with the abstract API.
3. The automatic component generation apparatus according to claim 2, wherein the internal data is generated by repeatedly executing the BODY generation unit recursively by replacing with the BODY of the component. 7. An environment-independent component definition, an environment-dependent component definition, an application environment definition, a component definition template for a specific environment, a basic description rule for a specific environment, and a customization metaprogram, Using the stored data to control the operation of the program automatic generation process, when operating a component once created in a new environment, without changing the environment-independent component related to the environment-dependent component And a description corresponding to a new programming language environment to be added later to the program automatic generation device, and automatically generating a source file of a new programming language environment of an existing component. 8. The environment-independent component is one in which each BODY uses only an abstract API, and the environment-dependent component is any native code in a specific programming language environment in each BODY. The method for automatically generating a component according to claim 7, wherein whether or not to write is written. 9. The program automatic generation processing includes: setting for generating the contents of an API; generating internal data; and executing the AP corresponding to a target programming language environment.
Generating I and the contents of the API as internal data, generating source code for a target environment of each component as internal data, and generating an image of the generated source code as internal data. Item 9. The method for automatically generating a component according to Item 7 or 8.