JP4988226B2 - PROGRAM GENERATION DEVICE, PROGRAM GENERATION METHOD, PROGRAM, AND RECORDING MEDIUM - Google Patents

Description

  The present invention relates to program generation control for generating a program to be executed by a computer.

  In general, system development work has been made more efficient by automatically generating a source program using an automatic program generation tool such as a CASE (Computer Aided Software Engineering) tool.

As an example, Patent Document 1 discloses that basic business logic (source program) including a screen program is automatically generated by designating data items (definition information) and business rules. Patent Document 1 describes that a source program related to a business application can be created without a user's knowledge of programming.
JP 2004-265278 A

  However, a source program generated by using a conventional program automatic generation tool is generally redundant, and the size of the source program increases according to the specified definition information.

  The large source program created in this way may cause the following problems (1) to (3).

  (1) When compiling a source program, there is a size that can be compiled for each compiler (hereinafter referred to as a compilation limit value). Therefore, if a source program exceeding the compilation limit value is compiled, compilation may fail.

  For example, as in Patent Document 1, when the generated program is JSP, it is once converted into a Java (registered trademark) source file (by the Web application server being used). In this case, since many parts of the program processing are concentrated and converted in one method, the limit of “one method within 64 kB” of the Java (registered trademark) compiler is easily exceeded. That is, the compilation is likely to fail.

  Therefore, in order to successfully compile a source file that exceeds the compiler limit, the user manually edits the source program so that the automatically generated source program is within the compilation limit value. It may be possible to do so.

  (2) However, manual editing is very complicated. Furthermore, automatic program generation tools such as the CASE tool are provided so that even a user who is generally poor in programming knowledge can create a program, and such a user can edit it manually. It is difficult. In addition, manual editing by the user may degrade the quality of the program.

  (3) When the user manually changes the source program, the consistency of the association information between resources maintained by the CASE tool may be disturbed, and further, the user may not operate. Therefore, from the viewpoint of operation guarantee, there are many systems in which the user is prohibited from changing the source program manually.

  For this reason, for example, the user must redesign the screen input / output items originally contained in one screen into a plurality of screens so that they can be normally compiled. By adding such restrictions, it becomes difficult to design programs and systems with free ideas.

  The present invention has been made to solve the above-mentioned problems, and an object of the present invention is to automatically execute a source program that prevents the occurrence of a translation failure from the source program to the machine language due to the size of the source program. It is to provide a mechanism to create.

The present invention is a program generation apparatus that generates a source program, and stores a program template including a divided area start mark and a divided area end mark for identifying an area that can be divided and compiled in the source program. A first source program including the divided area start mark and the divided area end mark is generated from the means, user definition information input in advance for defining a screen, and a program template stored in the storage means. A source program generation unit and a specification for identifying a compilable area identified by the division area start mark and the division area end mark included in the first source program generated by the first source program generation unit as a division unit program It means, by the specifying means By using a plurality of divided unit program to be constant, and a second source program generating means for generating a second source program data size that does not exceed a predetermined limit value, the generated by the second source program generation means 2 A program for taking in a source program has a third source program generating means for generating a third source program replaced as a substitute for the divided portion of the first source program corresponding to the second source program. And

  According to the present invention, it is possible to design a system under the free idea of the designer without being aware of the restrictions on the compilation limit value, and to prevent the failure of translation from the source program into the machine language. Programs can be created easily.

  In addition, it is possible to design a system based on the designer's free idea without being conscious of the generated program structure, and to easily create a source program that can be efficiently translated from a source program to a machine language. There is an effect that can be created.

[First Embodiment]
Hereinafter, embodiments of the program generation device of the present invention will be described with reference to the drawings.

  In the present embodiment, automatic generation of a JSP program will be described particularly in a CASE tool environment that automatically generates software such as programs and screens constituting an application system. In the present embodiment, the “program” indicates a source program.

  In addition, the description of the CASE tool environment refers only to the portion directly related to the present invention.

  FIG. 1 is a block diagram showing the entire system of a program generation apparatus showing an embodiment of the present invention.

  In FIG. 1, reference numeral 103 denotes a program generation device, which is composed of an information processing device such as a personal computer. Reference numeral 102 denotes an input device for a keyboard and a pointing device (such as a mouse). Reference numeral 101 denotes a display device such as a display. Reference numeral 104 denotes an external storage device such as a hard disk drive (HDD).

  As shown in FIG. 1, the user browses the display device 101 and operates the input device 102 to instruct a program automatic generation command. Then, the program generation apparatus 103 that has received the instruction of the automatic program generation instruction causes the overall control unit 105 to automatically generate the JSP program. Details will be described below.

  First, the screen control unit 106 that has received the program automatic generation command delegates the processing to the program generation unit 107. The program generation unit 107 applies user-defined information 109 (FIG. 5 described later) that is input and set in advance based on the JSP program template 110 (FIG. 6 described later) stored in the external storage device (HDD) 104. A JSP program is generated and stored in the external storage device 104 as a JSP program 111 (FIG. 7 described later).

  After creating the JSP program 111, the program generation unit 107 delegates the processing to the program division unit 108. Then, the program dividing unit 108 divides the JSP program 111, creates a plurality of divided programs, and stores them in the external storage device 104 as the divided JSP programs 112 (FIGS. 9 and 10 described later).

  Note that the configuration in FIG. 1 is an example, and it is needless to say that there are various configuration examples depending on applications and purposes. As another configuration example, the program generation apparatus can be automatically generated by receiving a program automatic generation instruction from an information processing apparatus such as a personal computer (not shown) that is connected to a network and can communicate. .

  That is, as long as the functions of the present invention are realized, the present invention can be applied to a single device, a system composed of a plurality of devices, or a system that performs processing via a network. Can be applied.

  Here, the user definition information 109, the JSP program template 110, the JSP program 111, and the divided JSP program 112 stored in the external storage device 104 such as a hard disk drive (HDD) are respectively stored in a database (DB) or the like. It shall be.

  Next, the hardware configuration of the program generation device 103 shown in FIG. 1 will be described with reference to FIG.

  FIG. 2 is a block diagram showing a hardware configuration of the program generation apparatus 103 in FIG. 1, and the same components as those in FIG. 1 are denoted by the same reference numerals.

  In FIG. 2, 201 is a CPU (Central Processing Unit) 201 that summarizes access to various devices connected to the system bus 211 based on a control program stored in the ROM 203 or the external storage device 104. It is the structure which controls automatically.

  Connected to the system bus 211 is a RAM (Random Access Memory) 202 that functions as a main memory, work area, and the like of the CPU 201. In the ROM 203 or the external storage device 104, a BIOS (Basic Input / Output System), an operating system (hereinafter referred to as “OS”) program, which is a control program of the CPU 201, and processing executed by the program generation device 103 are realized. Various necessary programs are stored.

  The CPU 201 implements the functions and various operations of the overall control unit 105 shown in FIG. 1 by loading various programs necessary for execution of processing into the RAM 202 and executing the programs.

  The input device controller 206 controls input from the input device 102 such as a pointing device (not shown) or a keyboard (not shown). The display device controller 205 controls display on the display device 101 such as a CRT display or a liquid crystal display. The memory controller 207 controls access to the external storage device 104.

  The external storage device 104 stores a boot program (not shown), various application programs, font data, user files, and the like as the various programs described above.

  A communication I / F (communication interface) 204 can be connected to an information processing apparatus such as a personal computer via a communication line 212, and bidirectional communication is possible.

  For example, the CPU 201 performs WYSIWYG on the display device 101 by executing an outline font rasterization process on a display information area in the RAM 202. Further, the CPU 201 opens various registered windows based on commands instructed by a mouse cursor (not shown) on the display device 101 and executes various data processing.

  Hereinafter, with reference to FIGS. 3 to 10, the entire processing performed by the overall control unit 105 of the program generation apparatus 103 illustrated in FIG. 1 will be described.

  FIG. 3 is a flowchart showing an example of a first control processing procedure according to the present invention, and corresponds to the entire processing performed by the overall control unit 105 of the program generating apparatus 103 shown in FIG. Note that the processing in this flowchart is realized by the overall control unit 105 in which the CPU 201 illustrated in FIG. 2 reads out the program stored in the external storage device 104 to the RAM 202 and executes the program. In the figure, S301 to S303 indicate each step.

  In step S301, upon receiving an instruction of an automatic program generation command input from the input device 102, the screen control unit 106 in the overall control unit 105 delegates the process to the program generation unit 107, and proceeds to step S302.

  Next, in step S302, the program generation unit 107 executes a program generation process (details are shown in FIG. 4). When the process of step 302 is completed, the program generating unit 107 delegates the process to the program dividing unit 108 and proceeds to step S303.

  In step S303, the program dividing unit 108 executes processing for dividing the program generated in step 302 (details are shown in FIG. 8), generates a divided program, and ends the processing.

  FIG. 4 is a flowchart showing an example of the second control processing procedure in the present invention, and corresponds to the program generation processing shown in step S302 of FIG. Note that the processing of this flowchart is realized by the program generation unit 107 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S401 to S403 indicate steps.

  First, in step S <b> 401, the program generation unit 107 extracts (acquires) the user definition information 109 (FIG. 5) stored in the external storage device 104 and stores it in the RAM 202.

  An example of the user definition information 109 is shown in FIG.

  FIG. 5 is a diagram showing an example of the user definition information 109 shown in FIG. Here, as an example, user definition information defining an address book screen is shown.

  As illustrated in FIG. 5, the user definition information 109 includes “IO” 701, “IOITEM_ID” 702, and “IOITEM_NAME” 703.

  “IO” 701 stores “screen code”. In addition, “IOITEM_ID” 702 stores “codes of items in the screen”. Further, “IOITEM_NAME” 703 stores “display names of items in the screen”.

  Hereinafter, the description returns to the flowchart of FIG.

  Next, in step S <b> 402, the program generation unit 107 extracts (acquires) the JSP program template 110 stored in the external storage device 104 and stores it in the RAM 202.

  In step S403 of FIG. 4, the program generation unit 107 incorporates the user definition information acquired in step S401 into the predetermined variable portion of the JSP program template 110 acquired in step S402, thereby incorporating the JSP program (FIG. 7). Generate. Then, the generated JSP program is stored in the external storage device 104 as the JSP program 111, and the process ends.

  An example of the JSP program template 110 is shown in FIG.

  FIG. 6 is a diagram showing an example of the JSP program template 110 shown in FIG.

  The JSP program template 110 has predetermined variable portions 810 and 811 in advance, and “IOITEM_NAME” 703 and “IOITEM_ID” 702 of the user definition information 109 described above are incorporated into the variable portions 810 and 811 to be described later. In step S403, the JSP program 111 is generated.

  More specifically, the variable portion (“$ {ioitem.name}”) of “<th> $ {ioitem.name} </ th>” indicated by 810 in FIG. 6 includes the item “IOITEM_NAME” in FIG. “Name” and “telephone number” stored in the column 703 are incorporated into “<th> name </ th>” and “<th> telephone number </ th>”.

  Also, "<logic: iterate id =" $ {io} "name =" bean "property =" ioitems ">", "<td> <bean: write name =" $ {io "shown in 811 and 812 of FIG. } "property =" $ {ioitem.id} "/> </ td>" variable part ("$ {io}") "address" stored in the column of the item "IO" 701 in FIG. Is incorporated. In addition, “name” and “tel” stored in the column of the item “IOITEM_ID” 702 in FIG. 5 are incorporated in the variable portion 811 (“$ {ioitem.id}”). That is, 811 becomes "<logic: iterate id =" address "name =" bean "property =" ioitems ">". 812 is “<td> <bean: write name =“ address ”property =“ name ”/> </ td>” or “<td> <bean: write name =“ address ”property =“ tel ”/> </ Td> ". As a result, a JSP program to be described later is generated.

  FIG. 7 is a diagram showing an example of the JSP program 111 shown in FIG.

  In addition, in the JSP program template 110 shown in FIG. 6, division identification information used in the “program division” process 303 is incorporated in advance.

  Here, as shown in FIG. 6, the division identification information includes “division area start mark 804”, “division area end mark 805”, “global area start mark 801”, “ Global area end mark 802 "or the like.

  These pieces of division identification information 801, 802, 804, and 805 are information for identifying portions where no contradiction occurs even when the program is divided. That is, it is possible to divide at this division identification information. The division identification information 801, 802, 804, 805 is information as a comment line, and is information that does not affect the function of the program itself.

  Here, an area sandwiched between “division area start mark 804” and “division area end mark 805” is referred to as “division unit area 806”, and information (program) included in this “division unit area 806” is designated as “division unit area 806”. It will be called “unit program”.

  Further, an area sandwiched between “global area start mark 801” and “global area end mark 802” is called “global area 803”, and information included in “global area 803” is called “global information”. . The global information is information that is necessary for the divided programs described later.

  FIG. 8 is a flowchart showing an example of a third control processing procedure according to the present invention, and corresponds to the program division processing shown in step S303 of FIG. Note that the processing of this flowchart is realized by the program dividing unit 108 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S501 to S512 indicate each step.

  First, in step S501, the program dividing unit 108 reads one area of program code from the JSP program 111 generated in step 302 and stored in the external storage device 104 or the like. Specifically, for example, the program code is read from the top of the JSP program 111. At this time, the division identification information “global area start mark 801” and “global area end mark 802” or “divided area start mark 804” and “divided area end mark 805” is detected, and the detected division is detected. The program code of the area identified (specified) by the identification information is read. In this way, information on the range (the sandwiched area) specified by “global area start mark 801” and “global area end mark 802”, or “divided area start mark 804” and “divided area end mark 805”. The information of the range (the sandwiched area) specified by “is read.

  In step S502, the program dividing unit 108 specifies whether the information of one area in the JSP program 111 read in step S501 is “global information” or “division unit program” based on the division identification information. For example, if the read information is information in a range (interposed area) specified by “global area start mark 801” and “global area end mark 802”, it is specified as “global information”. Further, if the read information is information of a range (interposed area) specified by “divided area start mark 804” and “divided area end mark 805”, it is specified as “divided unit program”.

  In step S <b> 503, if the program dividing unit 108 determines that the information read in step 501 is “global information”, the process proceeds to step 504. In step S504, the program dividing unit 108 stores the information read in step S501 as “global information” in the RAM 202, and advances the process to step S512.

  On the other hand, if the program dividing unit 108 determines in step S503 that the information read in step 501 is not "global information", the process proceeds to step 505. In step S505, if the program dividing unit 108 determines that the information read in step S501 is not a “division unit program”, the program dividing unit 108 proceeds to step S512 as it is.

  On the other hand, if the program dividing unit 108 determines in step S505 that the information read in step S501 is a “division unit program”, the process proceeds to step S506.

  In step S506, the program dividing unit 108 newly generates an empty divided program (file) in the external storage device 104.

  In step S507, the program dividing unit 108 inserts “global information” stored in the RAM 202 into the divided program created in step 506 (shown at 1101 in FIG. 10).

  Next, in step 508, the program dividing unit 108 inserts the information read in step S501 as a “division unit program” into the divided program in which “global information” is inserted in step 507 (in step 1102 in FIG. 10). Show).

  In step S509, the program dividing unit 108 closes the divided program file. In this way, a division program as shown in FIG. 10 is generated. The divided program generated in this way is hereinafter referred to as a divided program (child). The divided program (child) is stored in the external storage device 104 or the like as one of the divided JSP programs 112.

  Next, in step S510, the program dividing unit 108 deletes the information (division unit program) inserted in the divided program in step S508 from the JSP program 111.

  Next, in step S511, the program dividing unit 108 includes the statement included in the file of the divided program (child) generated in steps S506 to S509 in the portion of the divided unit program deleted in step 510 in the JSP program 111. Is inserted (shown at 1002 in FIG. 9). Here, the include statement includes path information such as a relative path or an absolute path that identifies the file of the split program (child).

  Next, in step 512, the program dividing unit 108 determines whether or not reading of all the division unit programs and global information of the JSP program 111 has been completed. The process returns to S501. By repeating the above processing until the reading of the JSP program 111 is completed, the files of the divided programs (children) corresponding to the divided unit programs as shown in FIG. 10 are respectively generated, and the JSP program shown in FIG. 111 is edited as shown in FIG. The JSP program 111 edited in this way is hereinafter referred to as a divided program (parent).

  On the other hand, if it is determined in step 512 that the program dividing unit 108 has finished reading all the division unit programs and global information of the JSP program 111, the program is edited by the processing in steps S510 and S511 in steps not shown. The generated divided program (parent) is also stored in the external storage device 104 as the divided JSP program 112, and the process is terminated.

  As a result of the above “program division” process, the post-division JSP program 112 shown in FIGS. 9 and 10 is created. 9 and FIG. 10, the “global area start mark 801”, “global area end mark 802”, “divided area start mark 804”, and “divided area end mark 805” are not shown. Since these are comment lines, there is no problem even if they are included in the split program.

  FIG. 9 is a diagram showing an example of a divided program (parent) generated by the program dividing process shown in FIG.

  The division program (parent) shown in FIG. 9 includes global information 1001 necessary for any division program. Further, the divided program (parent) includes the number of programs obtained by dividing the include statement 1002 including the path information to each divided program (child).

  In the flowchart shown in FIG. 8, a method of generating the split program (parent) of FIG. 9 by deleting the split unit program from the original JSP program 111 and inserting the include statement of the split program (child). Showed about. However, the divided program (parent) shown in FIG. 9 also generates a new program file and generates global information and an include statement of each divided program (child) in the generated program file. You may comprise.

  FIG. 10 is a diagram showing an example of the divided program (child) generated in steps S506 to S509 of the program dividing process shown in FIG.

  The division program (child) shown in FIG. 10 includes global information 1101 and a division unit program 1102.

  As described above, in the present embodiment, the program generation unit 107 sets the mark information (global area start mark 801, global area end mark 802, divided area start mark) at a position where the file (JSP program 111) to be generated can be divided. 804 and a divided area end mark 805) are embedded, and the program dividing unit 108 is configured to divide the program using the mark. Thereby, it is possible to easily divide the automatically generated program, which has been difficult until now, without manual editing by the user.

  Therefore, system design can be performed under the free idea of the designer without being aware of the restrictions on the compilation limit values and the program structure, preventing failure of translation from the source program to machine language. It is possible to create a source program that prevents deterioration of system performance due to work editing.

[Second Embodiment]
In the first embodiment, the configuration in which a program is divided in divided program units has been described. In the case of the configuration of the first embodiment, there is a possibility that the division unit of the program becomes small and there is a possibility that the program cannot be efficiently compiled. In the present embodiment, the program is divided for each number of division unit programs designated by the user. Hereinafter, a detailed description will be given with reference to FIGS.

  FIG. 11 is a diagram showing an example of a program generation instruction screen in the second embodiment of the present invention. This program generation screen is displayed on the display device 101 shown in FIG.

  In FIG. 11, a down menu 1501 can set a program to be generated. The check boxes 1502 and 1503 can set whether or not to divide the program generated in the “program generation” process (step 302). Note that check boxes 1502 and 1503 are check boxes that can be checked exclusively. When the program is divided, the check box 1502 is checked, and when the program is not divided, the check box 1503 is checked.

  The pull-down menu 1504 can set how many division unit programs can be inserted into the division program. For example, if the division unit is set to “5”, a division program in which five division unit programs are inserted can be generated. Information set in steps 1501 to 1504 is referred to as setting information.

  When the user sets setting information using the input device 102 and presses the “Generate” button 601, the input device 102 sends the setting information and the program automatic generation command set to the program generating device 103. Thereby, the process (FIG. 3) by the program generation apparatus 103 is started.

  Hereinafter, with reference to FIG. 12, the program division processing (S303 in FIG. 3) in the second embodiment of the present invention will be described.

  FIG. 12 is a flowchart showing an example of a fourth control processing procedure in the present invention, and corresponds to the program division processing (S303 in FIG. 3) in the second embodiment of the present invention. Note that the processing of this flowchart is realized by the program dividing unit 108 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S1201 to S1215 indicate steps.

  First, in step S1201, the program dividing unit 108 determines whether to divide the program generated in step S302 in FIG. 3 based on setting information (particularly 1502 and 1503 in FIG. 11). If the program dividing unit 108 determines not to divide, the process is terminated as it is.

  On the other hand, if the program dividing unit 108 determines in step S1201 to divide the program generated in step S302 of FIG. 3, the process proceeds to step S1202.

  Note that the processing in steps S1202 to S1206 is the same as the processing in steps S501 to S505 in FIG.

  If the program dividing unit 108 determines in step S1206 that the information read in step S1202 is a “division unit program”, the process proceeds to step S1207.

  In step S1207, the program dividing unit 108 determines whether or not the number of division unit programs already inserted in the division program (file) is less than the number of division units set in the setting information (particularly 1504 in FIG. 11). . If it is determined that the number of division unit programs already inserted into the division program (file) is less than the number of division units, the process proceeds to step 1210.

  In step S1210, the program dividing unit 108 determines whether there is a divided program (file) being processed. If it is determined that there is no divided program (file) being processed, the process proceeds to step 1211.

  In step S1211, the program dividing unit 108 newly generates an empty divided program (file) in the external storage device 104.

  In step S1212, the program dividing unit 108 inserts “global information” stored in the RAM 202 into the divided program created in step 1211 (1101 in FIG. 10).

  Next, in step 1213, the program dividing unit 108 inserts the information read in step S1202 as the “division unit program” into the divided program in which “global information” is inserted in step 1212 (1102 in FIG. 10). .

  Next, in step S1214, the program dividing unit 108 deletes the information (division unit program) inserted in the divided program in step S1212 from the JSP program 111, and the process proceeds to step S1215.

  If the program dividing unit 108 determines in step S1210 that there is a divided program (file) being processed, the process of steps S1213 and S1214 is executed as it is, and the process proceeds to step S1215.

  Next, in step 1215, the program dividing unit 108 determines whether or not reading of all the division unit programs and global information of the JSP program 111 has been completed. The process returns to S1202.

  If the program dividing unit 108 determines in step S1207 that the number of division unit programs already inserted in the division program (file) is less than the number of division units set in the setting information (particularly 1504 in FIG. 11). In step S1208, the process proceeds to step 1208.

  In step S1208, the program dividing unit 108 closes the file of the divided program being processed. Thereby, a division program is created. This divided program is called a divided program (child). The divided program (child) is stored in the external storage device 104 or the like as one of the divided JSP programs 112.

  Next, in step S1209, the program dividing unit 108 includes an include statement in the file of the divided program (child) closed in step S1208 in the JSP program 111 (in the portion of the division unit program deleted in step 1214). It is inserted (1002 in FIG. 9). Here, the include statement includes path information such as a relative path or an absolute path that identifies the file of the split program (child). When the process of step S1209 ends, the processes of steps S1210 to S1214 are executed, and the process proceeds to step S1215.

  By repeating the processes in steps S1202 to S1214 until the reading of the JSP program 111 is completed, the files of the divided programs (children) corresponding to the divided unit programs as shown in FIG. 10 are generated, and FIG. The JSP program 111 shown in FIG. 9 is edited as shown in FIG. The JSP program 111 edited in this way is referred to as a divided program (parent).

  If the program division unit 108 determines in step 1215 that reading of all the division unit programs and global information of the JSP program 111 has been completed, the program is edited by the processing in steps S510 and S511 in steps not shown. The generated divided program (parent) is also stored in the external storage device 104 as the divided JSP program 112, and the process is terminated.

  As described above, the present embodiment has a configuration in which the program dividing unit 108 divides the program generated by the program generating unit 107 so as to include the number of divided programs specified by the user. Thereby, the division program including the division unit program of the number of division units designated by the user can be easily generated without manual editing by the user.

  Therefore, it is possible to generate a divided program that can generate fewer divided programs so that the compile process can be performed efficiently or that compile errors are less likely to occur.

  That is, there is a trade-off that the initial compilation is slowed down instead of being able to process more information when finely divided, but the user can select this according to the case.

  In step 1201 of FIG. 12, the size of the JSP program 111 generated in step 302 and the compilation limit value of the compiler are acquired, the size of the JSP program 111 is compared with the compilation limit value, and the JSP If the size of the program 111 exceeds the compile limit value, the process of step 1202 is executed (process for generating a divided program is executed). If not, the process for generating a divided program is not executed and the process ends. You may comprise.

  The compile limit value indicates a size that can be compiled by the compiler, and can be dynamically acquired from the compiler. The compile limit value may be stored in advance in the external storage device 104 as a setting file or the like.

[Third Embodiment]
In the second embodiment, the configuration in which the division program is generated so as to include the number of division unit programs specified by the user has been described. In this embodiment, the division program is configured to include division unit programs within the number specified by the user and to generate the division program so that the size of the division program does not exceed the compilation limit value. Hereinafter, a detailed description will be given with reference to FIGS. 13 and 14.

  FIG. 13 is a flowchart showing an example of a fifth control processing procedure according to the present invention, and corresponds to the program division processing (S303 in FIG. 3) according to the third embodiment of the present invention. Note that the processing of this flowchart is realized by the program dividing unit 108 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S1201 to S1215 and S1300 indicate each step. Moreover, the same step number is attached | subjected to the step same as FIG. 12, and description is abbreviate | omitted.

  If the program dividing unit 108 determines in step S1210 that there is a divided program (file) being processed, the program dividing unit 108 proceeds to step S1300.

  In step S1300, the program dividing unit 108 executes compile limit size processing, and proceeds to step S1213. Details of the compile limit size process in step S1300 are shown in FIG.

  FIG. 14 is a flowchart showing an example of the sixth control processing procedure in the present invention, and corresponds to the compile limit size processing in step S1300 in FIG. Note that the processing of this flowchart is realized by the program dividing unit 108 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S1301 to S1303 indicate each step.

  In step S1301, the program dividing unit 108 acquires the size of the divided program (file) being processed, the size of the divided unit program being processed, and the compiler compilation limit value. Then, the program dividing unit 108 determines whether or not the total value of the size of the divided program being processed and the size of the divided unit program being processed exceeds the compile limit value.

  When the program dividing unit 108 determines that the total value of the size of the divided program being processed and the size of the divided unit program being processed does not exceed the compilation limit value, the process proceeds to step S1213 in FIG. .

  On the other hand, if the program dividing unit 108 determines that the total value of the size of the divided program being processed and the size of the divided unit program being processed exceeds the compilation limit value, the process proceeds to step S1302.

  In step S1302, the program dividing unit 108 closes the file of the divided program being processed. Thereby, a division program is created. This divided program is called a divided program (child). The divided program (child) is stored in the external storage device 104 or the like as one of the divided JSP programs 112.

  Next, in step S1303, the program dividing unit 108 adds to the file of the divided program (child) closed in step S1301 in the JSP program 111 (in the portion of the division unit program deleted in step 1214 in FIG. 13). An include statement is inserted (1002 in FIG. 9). Here, the include statement includes path information such as a relative path or an absolute path that identifies the file of the split program (child). When the process of step S1303 ends, the process proceeds to step S1213 of FIG.

  By executing the above process, a compile process can be performed efficiently, and a divided program that can prevent a compile error can be generated.

[Fourth Embodiment]
In the first embodiment, the configuration for dividing the automatically generated program has been described. In the present embodiment, a “program synthesis” process for synthesizing a program divided by the program division process shown in the first embodiment into a size that can be efficiently compiled is configured. Hereinafter, a detailed description will be given with reference to FIGS. 15 and 16.

  FIG. 15 is a flowchart showing an example of the seventh control processing procedure according to the present invention, and corresponds to the entire processing performed by the overall control unit 105 according to the fourth embodiment of the present invention. Note that the processing in this flowchart is realized by the overall control unit 105 in which the CPU 201 illustrated in FIG. 2 reads out the program stored in the external storage device 104 to the RAM 202 and executes the program. In the figure, S301 to S303 and S1400 indicate each step. Moreover, the same step number is attached | subjected to the step same as FIG. 12, and description is abbreviate | omitted.

  When the program dividing unit 108 completes the program dividing process in step S303, the program dividing unit 108 proceeds to step S1400 and executes the program synthesis process. Details of the program synthesis process in step S1400 are shown in FIG.

  FIG. 16 is a flowchart showing an example of the eighth control processing procedure in the present invention, and corresponds to the program synthesis processing in step S1400 of FIG. Note that the processing of this flowchart is realized by the program dividing unit 108 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S1401 to S1410 indicate each step.

  In step S1401, the program dividing unit 108 creates a new empty synthesis program file in the external storage device 104.

  Next, in step S1402, the program dividing unit 108 acquires one divided program (child) from the plurality of divided programs (child) divided in step S303 in FIG. Hereinafter, this division program (child) is referred to as “the current division program”.

  In step S1403, the program dividing unit 108 acquires the size of the synthesis program being processed, the size of the current divided program, and the compiler compilation limit value. Then, the program dividing unit 108 determines whether or not the total value of the size of the synthesis program being processed and the size of the current divided program exceeds the compilation limit value.

  If the program dividing unit 108 determines that the total value of the size of the synthesis program being processed and the size of the current divided program does not exceed the compilation limit value, the process proceeds to step S1404.

  In step S1404, the program dividing unit 108 copies the contents of the current divided program (“global information”, “division unit program”) to the synthesis program being processed. Here, when copying to an empty synthesis program for the first time, the “global information” and “division unit program” of the current division program are copied to the synthesis program being processed. However, if “global information” is already included in the synthesis program (that is, the second and subsequent copy processing), only the “division unit program” in the current division program is copied to the synthesis program being processed. To do.

  In step S1405, the program dividing unit 108 deletes the divided program copied in step 1404.

  In step S1406, the program dividing unit 108 deletes the include statement for specifying the current divided program inserted in the original JSP program (divided program (parent)). Then, the process proceeds to step S1410.

  Next, in step 1410, the program dividing unit 108 determines whether or not the processing of S1402 to S1406 has been completed for all of the divided programs (children). If it is determined that the processing has not been completed, step S1402 Return processing to.

  If the program dividing unit 108 determines in step S1403 that the total value of the size of the synthesis program being processed and the size of the current divided program exceeds the compilation limit value, the process proceeds to step S1407.

  In step S1407, the program dividing unit 108 closes the synthesis program being processed.

  Next, in step S1408, the program dividing unit 108 inserts an include statement for specifying the synthesis program closed in step 1406 into the original JSP program (divided program (parent)).

  Next, in step S1409, the program dividing unit 108 creates a new empty synthesis program file, executes the processing of steps 1404 to S1406, and advances the processing to step S1410.

  In step 1410, when the program dividing unit 108 determines that the processing of S1402 to S1406 has been completed for all of the divided programs (children), the synthesis program edited and generated by the above processing in the step (not shown). The divided JSP program 112 is stored in the external storage device 104, and the process is terminated.

  Through the above processing, instead of the trial and error division specified by the user as shown in the second embodiment, after the division by the division method shown in the first embodiment, the file is automatically resized to a compilable size. Can be synthesized. As a result, it is possible to generate a divided program (synthetic program) that can efficiently perform the compile process and prevent a compile error.

  Note that the division method according to this embodiment uses significant mark information (division identification information) instead of generating a division from the beginning as shown in the second, third, and fourth embodiments. After the division, the program synthesis process is executed and re-synthesized. However, a further process (for example, a compile process) may be added after the program synthesis process.

  It should be noted that the configuration and contents of the various data described above are not limited to this, and it goes without saying that the various data and configurations are configured according to the application and purpose.

  Although one embodiment has been described above, the present invention can take an embodiment as, for example, a system, apparatus, method, program, or recording medium, and specifically includes a plurality of devices. The present invention may be applied to a system including a single device.

  The configuration of a data processing program that can be read by the program generation device (computer) according to the present invention will be described below with reference to the memory map shown in FIG.

  FIG. 17 is a diagram illustrating a memory map of a recording medium (storage medium) that stores various data processing programs readable by the program generation apparatus (computer) according to the present invention.

  Although not specifically shown, information for managing a program group stored in the recording medium, for example, version information, creator, etc. is also stored, and information depending on the OS on the program reading side, for example, a program is identified and displayed. Icons may also be stored.

  Further, data depending on various programs is also managed in the directory. In addition, when a program or data to be installed is compressed, a program to be decompressed may be stored.

  3, 4, 8, 12, 13, 14, 15, and 16 in this embodiment may be performed by a host computer by a program installed from the outside. In this case, the present invention is applied even when an information group including a program is supplied to the output device from a recording medium such as a CD-ROM, a flash memory, or an FD, or from an external recording medium via a network. Is.

  As described above, a recording medium in which a program code of software for realizing the functions of the above-described embodiments is recorded is supplied to the system or apparatus, and the computer (or CPU or MPU) of the system or apparatus is stored in the recording medium. It goes without saying that the object of the present invention can also be achieved by reading and executing the program code.

  In this case, the program code itself read from the recording medium realizes the novel function of the present invention, and the recording medium storing the program code constitutes the present invention.

  As a recording medium for supplying the program code, for example, a flexible disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, DVD-ROM, magnetic tape, nonvolatile memory card, ROM, EEPROM, A silicon disk or the like can be used.

  Further, by executing the program code read by the computer, not only the functions of the above-described embodiments are realized, but also an OS (operating system) or the like running on the computer based on the instruction of the program code. It goes without saying that a case where the function of the above-described embodiment is realized by performing part or all of the actual processing and the processing is included.

  Furthermore, after the program code read from the recording medium is written in a memory provided in a function expansion board inserted in the computer or a function expansion unit connected to the computer, the function expansion is performed based on the instruction of the program code. It goes without saying that the case where the CPU or the like provided in the board or the function expansion unit performs part or all of the actual processing and the functions of the above-described embodiments are realized by the processing.

  Further, the present invention may be applied to a system composed of a plurality of devices or an apparatus composed of a single device. Needless to say, the present invention can be applied to a case where the present invention is achieved by supplying a program to a system or apparatus. In this case, by reading a recording medium storing a program represented by software for achieving the present invention into the system or apparatus, the system or apparatus can enjoy the effects of the present invention.

  Furthermore, by downloading and reading out a program represented by software for achieving the present invention from a server, database, etc. on a network using a communication program, the system or apparatus can enjoy the effects of the present invention. It becomes.

  In addition, all the structures which combined each embodiment mentioned above and its modification are also included in this invention.

It is a block diagram which shows the whole system of the program production | generation apparatus which shows one Embodiment of this invention. It is a block diagram which shows the hardware constitutions of the program production | generation apparatus 103 of FIG. It is a flowchart which shows an example of the 1st control processing procedure in this invention. It is a flowchart which shows an example of the 2nd control processing procedure in this invention. It is a flowchart which shows an example of the 2nd control processing procedure in this invention. It is a figure which shows an example of the user definition information shown in FIG. It is a figure which shows an example of the JSP program template shown in FIG. It is a figure which shows an example of the JSP program shown in FIG. It is a flowchart which shows an example of the 3rd control processing procedure in this invention. It is a figure which shows an example of the division | segmentation program (parent) produced | generated by the program division | segmentation process shown in FIG. It is a figure which shows an example of the division | segmentation program (child) produced | generated by step S506-S509 of the program division | segmentation process shown in FIG. It is a figure which shows an example of the program production | generation command screen in 2nd Embodiment of this invention. It is a flowchart which shows an example of the 4th control processing procedure in this invention. It is a flowchart which shows an example of the 5th control processing procedure in this invention. It is a flowchart which shows an example of the 6th control processing procedure in this invention. It is a flowchart which shows an example of the 7th control processing procedure in this invention. It is a flowchart which shows an example of the 8th control processing procedure in this invention. It is a figure explaining the memory map of the recording medium (storage medium) which stores the various data processing program which can be read with the program generation apparatus (computer) which concerns on this invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 101 Input device 102 Display device 103 Program generation device 104 External storage device 105 Overall control unit 106 Screen control unit 107 Program generation unit 108 Program division unit 109 User definition information 110 JSP program template 111 JSP program 112 JSP program after division

Claims (6)

A program generation device for generating a source program,
Storage means for storing a program template including a divided area start mark and a divided area end mark for identifying an area that can be divided and compiled in the source program;
First source program generation for generating a first source program including the divided area start mark and the divided area end mark based on user definition information input in advance for defining a screen and a program template stored in the storage unit Means,
Specifying means for specifying a compilable area identified by the divided area start mark and divided area end mark included in the first source program generated by the first source program generating means as a divided unit program;
Second source program generating means for generating a second source program having a data size not exceeding a predetermined limit value by using a plurality of division unit programs specified by the specifying means;
Generate a third source program in which the program for taking in the second source program generated by the second source program generating means is replaced as a substitute for the divided portion of the first source program corresponding to the second source program Third source program generating means for performing,
A program generation apparatus comprising: The division area start mark and the division area end mark identify the first division area start mark and the first division area end mark for identifying areas that are necessary even after division, and the area where the source program can be divided. Including a second divided area start mark and a second divided area end mark,
The specifying unit specifies a common program that is necessary even after the division based on the first divided area start mark and the first divided area end mark included in the first source program generated by the first source program generating unit. And specifying a division unit program to be a division unit based on a second division area start mark and a second division area end mark included in the first source program,
2. The program generation apparatus according to claim 1, wherein the second source program generation unit generates the second source program by a common program and a division unit program specified by the specification unit. The limit value, the program generating apparatus according to claim 1 or 2, characterized in that it presents a compilable largest source program size. A program generation method for generating a source program,
The first source program generation means, user-defined information input in advance for defining the screen, and a divided area start mark for identifying the divided and compilable area in the source program stored in the storage means A first source program generating step for generating a first source program including the divided area start mark and the divided area end mark by a program template including the divided area end mark;
A specifying step for specifying a compilable area identified by the divided area start mark and the divided area end mark included in the first source program generated in the first source program generating step as a divided unit program; ,
A second source program generating step for generating a second source program having a data size not exceeding a predetermined limit value by using a plurality of division unit programs specified in the specifying step;
The third source program generating means replaces the program for taking in the second source program generated in the second source program generating step, instead of the divided portion of the first source program corresponding to the second source program. And a third source program generating step for generating the third source program thus generated. Computer
Storage means for storing a program template including a divided area start mark and a divided area end mark for identifying an area that can be divided and compiled in the source program;
First source program generation for generating a first source program including the divided area start mark and the divided area end mark based on user definition information input in advance for defining a screen and a program template stored in the storage unit means,
Specifying means for specifying a compilable area identified by the divided area start mark and divided area end mark included in the first source program generated by the first source program generating means as a divided unit program;
Second source program generating means for generating a second source program having a data size not exceeding a predetermined limit value by using a plurality of division unit programs specified by the specifying means;
Generate a third source program in which the program for taking in the second source program generated by the second source program generating means is replaced as a substitute for the divided portion of the first source program corresponding to the second source program A program for functioning as third source program generating means. Computer
Storage means for storing a program template including a divided area start mark and a divided area end mark for identifying an area that can be divided and compiled in the source program;
First source program generation for generating a first source program including the divided area start mark and the divided area end mark based on user definition information input in advance for defining a screen and a program template stored in the storage unit means,
Specifying means for specifying a compilable area identified by the divided area start mark and divided area end mark included in the first source program generated by the first source program generating means as a divided unit program;
Second source program generating means for generating a second source program having a data size not exceeding a predetermined limit value by using a plurality of division unit programs specified by the specifying means;
Generate a third source program in which the program for taking in the second source program generated by the second source program generating means is replaced as a substitute for the divided portion of the first source program corresponding to the second source program A computer-readable recording medium having recorded thereon a program for functioning as third source program generating means.

Images