KR102612934B1 - System, server and method for automatically generating stacked code based on tree structure infomation - Google Patents

Abstract

A method for automatically generating a stacked code based on tree structure information according to the present invention includes the steps of receiving tree structure information in a predetermined form including structure information and logic information of software to be designed from a client terminal; generating structure information from the tree structure information based on a stacked automatic code generation algorithm; generating a project and source code corresponding to the design target software based on the structure information; and transmitting the generated project and source code to the client terminal.

Description

System, server, and method for automatically generating stacked code based on tree structure information {SYSTEM, SERVER AND METHOD FOR AUTOMATICALLY GENERATING STACKED CODE BASED ON TREE STRUCTURE INFOMATION}

The present invention relates to a system, server, and method for automatically generating stacked codes based on tree structure information, particularly for code creation, modification, and maintenance in the process of developing software for controlling defense-related equipment, such as tanks and ships. to be able to perform efficiently.

Conventional code writing and management techniques primarily refer to using text-based approaches to develop software. This method has the disadvantage of requiring the developer to remember the commands and syntax of the code and write the source code one by one based on them. Additionally, such code is likely to be less readable and less reusable and maintainable, which can result in software development taking a lot of time and money.

To overcome these limitations, some prior technologies have introduced a method in which developers utilize a user interface to write code by providing a visual programming environment. In this environment, blocks or components can be visually arranged to implement program functions, and the structure and operation of the program can be visualized by connecting them. However, this method is mainly used for simple projects or educational purposes, and may provide limited functionality or cause scalability problems in complex projects.

Additionally, among conventional technologies, there is also a method of automatically generating source code based on a program design created by a developer using a code generation tool. These tools primarily work using a template-based approach. Developers generate code by selecting or modifying predefined templates. However, this approach is limited by the functionality and structure provided by the template, making it difficult for developers to modify or extend the code to suit their needs.

As such, existing software development technologies have limitations in terms of efficiency and flexibility, which can make it difficult to respond to complex projects or changing requirements.

The problem that the present invention aims to solve is a layered code based on tree structure information that can automatically generate source code for each node while improving code reusability and modularity through tree structure information expressing interactions between nodes. It relates to an automatic generation system, server, and method.

However, the problem to be solved by the present invention is not limited to the problems described above, and other problems may exist.

The method of automatically generating a stacked code based on tree structure information according to the first aspect of the present invention to solve the above-described problem includes receiving tree structure information in a predetermined form including structure information and logic information of the software to be designed from a client terminal. steps; generating structure information from the tree structure information based on a stacked automatic code generation algorithm; generating a project and source code corresponding to the design target software based on the structure information; and transmitting the generated project and source code to the client terminal.

In some embodiments of the present invention, the step of receiving tree structure information in a predetermined form including structure information and logic information of the software to be designed from the client terminal includes the tree structure information converted to JSON type from the client terminal. can receive.

In some embodiments of the present invention, the tree structure information includes a project node that is the highest node representing the design target software, a project setting node and a class node that are lower nodes of the project node, and lower nodes of the project setting node. It may include an in-release node and a debug node, and a header file node and a source file node that are child nodes of the class node.

In some embodiments of the present invention, generating structure information from the tree structure information based on the stacked automatic code generation algorithm includes generating a project template data structure based on the tree structure information; generating a project setting data structure based on project setting information included in the project template data structure; and generating a class template data structure and a function template data structure based on class and function information extracted from the tree structure information.

In some embodiments of the present invention, the step of generating a project template data structure based on the tree structure information may generate a project template data structure including the name of the project, the supported platform version, and the project setting information. there is.

In some embodiments of the present invention, the step of creating a project settings data structure based on the project settings information included in the project template data structure includes the name of the project settings corresponding to the project, the platform of the project settings, and the project. The project setting data structure can be created including the paths of header files and source files to be included, additional include directories, library directories, and project dependency information.

In some embodiments of the present invention, the step of generating a class template data structure and a function template data structure based on class and function information extracted from the tree structure information includes the name of the class, the member variable type of each class, The class template data structure can be created including name and annotation information for the corresponding variable, and template data information of member functions, initialization functions, and termination functions to be defined in the class.

In some embodiments of the present invention, the step of generating a class template data structure and a function template data structure based on the class and function information extracted from the tree structure information includes the name of the function and the parameters stored in the form of a tuple. Type and name, name of function return type and return value storage variable, exception handling method according to return value of initialization or termination statement, content of function comment, name of member variable object required when called in initialization or termination statement, additional settings of function The function template data structure containing value information can be created.

In some embodiments of the present invention, generating structure information from the tree structure information based on the stacked automatic code generation algorithm includes generating an advanced information set structure including additional settings required when initializing functions. may include.

In addition, the automatic stacked code generation server based on tree structure information according to the second aspect of the present invention receives tree structure information in a predetermined form including structural information and logic information of the design target software from the client terminal, and generates the generated project. and a communication module that transmits the source code to the client terminal, a memory storing a program for generating the project and source code based on the tree structure information, and a stacked automatic code generation algorithm by executing the program stored in the memory. and a processor that generates structure information from the tree structure information and generates a project and source code corresponding to the design target software based on the structure information.

In some embodiments of the present invention, the communication module may receive the tree structure information converted to JSON type from the client terminal.

In some embodiments of the present invention, the tree structure information includes a project node that is the highest node representing the design target software, a project setting node and a class node that are lower nodes of the project node, and lower nodes of the project setting node. It may include an in-release node and a debug node, and a header file node and a source file node that are child nodes of the class node.

In some embodiments of the present invention, the processor generates a project template data structure based on the tree structure information, generates a project settings data structure based on project setting information included in the project template data structure, and A class template data structure and a function template data structure can be created based on class and function information extracted from tree structure information.

In some embodiments of the present invention, the processor may generate a project template data structure including the name of the project, a supported platform version, and the project setting information.

In some embodiments of the present invention, the processor configures the name of the project setting corresponding to the project, the platform of the project setting, the path of the header file and source file to be included in the project, an additional additional include directory, a library directory, and project dependency. The project setting data structure containing information can be created.

In some embodiments of the present invention, the processor stores the name of the class, the type of member variable of each class, the name and annotation information for the variable, and the template data of the member function, initialization function, and termination function to be defined in the class. The class template data structure containing information can be created.

In some embodiments of the present invention, the processor processes exception handling according to the name of the function, the type and name of the parameter stored in the form of a tuple, the name of the function return type and return value storage variable, and the return value of the initialization or termination statement. The function template data structure can be created including the method, the content of the function comment, the name of the member variable object required when calling in the initialization or termination statement, and the additional setting value information of the function.

In some embodiments of the present invention, the processor may generate an advanced information set structure that includes additional settings required when initializing functions.

In addition, the automatic stacked code generation system based on tree structure information according to the third aspect of the present invention generates tree structure information including structure information and logic information of the software to be designed through a user interface, and prescribes the tree structure information. A client terminal for converting into a form, receiving the converted tree structure information, generating structure information from the tree structure information based on a stacked automatic code generation algorithm, and corresponding to the design target software based on the structure information. It includes a server that generates a project and source code and transmits them to the client terminal.

A computer program according to another aspect of the present invention for solving the above-described problem is combined with a hardware computer to execute the tree structure information-based automatic stacked code generation method, and is stored in a computer-readable recording medium.

Other specific details of the invention are included in the detailed description and drawings.

According to an embodiment of the present invention described above, software components are visualized in a hierarchical tree structure so that developers can more easily understand and work on the overall architecture. When developers write and modify code, they can intuitively understand the structure and interactions, which can improve work efficiency, which reduces the time it takes developers to understand complex code logic, prevents mistakes, and saves work time. It can help to shorten .

Additionally, according to one embodiment of the present invention, code quality can be improved by making software more modular and separating it into reusable components. As modularity increases, code writing becomes clearer and more consistent, and reusable parts can be used in multiple projects, increasing development efficiency. This can improve code readability and make it easier to maintain.

Additionally, according to an embodiment of the present invention, scalability and collaboration can be strengthened to improve the productivity of the development team regardless of project size and complexity. Additionally, collaboration can be easily achieved and an environment where multiple developers can work simultaneously can be provided, speeding up project progress and making the development process more smooth.

In addition, according to one embodiment of the present invention, the time for developers to manually write code is greatly reduced by applying an automatic code generation method, which contributes to reducing costs incurred in the development process. In addition, maintenance costs are reduced due to improvements in code quality, and structured code with fewer errors can respond more easily to modifications or extensions, which has the advantage of reducing additional costs.

In addition, according to one embodiment of the present invention, it provides flexibility for developers to modify or extend the code to suit their needs, and generates code based on predefined structures and functions, but the developer modifies it if necessary. or extend it to customize the code to fit the needs of your project.

Overall, the tree structure-based stacked code automatic generation method according to the present invention helps developers work more efficiently in the software development process and contributes to generating high-quality code while saving development costs and time. , this method can further improve the efficiency and flexibility of software development.

The effects of the present invention are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

The drawings attached below are intended to aid understanding of the present embodiment and provide examples along with a detailed description. However, the technical features of this embodiment are not limited to specific drawings, and the features disclosed in each drawing may be combined to form a new embodiment.
1 is a diagram illustrating an automatic stacked code generation system based on tree structure information according to an embodiment of the present invention.
Figure 2 is a diagram for explaining a user interface provided by a client terminal.
Figure 3 is a block diagram of a stacked code automatic generation server based on tree structure information according to an embodiment of the present invention.
Figure 4 is a diagram for explaining tree structure information in an embodiment of the present invention.
5A to 5C are diagrams illustrating an example of converting tree structure information into JSON type.
Figure 6 is a diagram showing structure information in one embodiment of the present invention.
Figure 7 is a diagram for explaining a stacked code conversion process of tree structure information in an embodiment of the present invention.
Figure 8 is a diagram showing an example of the result of generating a header file based on structure information.
FIGS. 9A and 9B are diagrams showing an example of the results of generating a source file based on structure information.
Figure 10 is a flowchart of a method for automatically generating a stacked code performed on a server according to an embodiment of the present invention.

The advantages and features of the present invention and methods for achieving them will become clear by referring to the embodiments described in detail below along with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below and may be implemented in various different forms. The present embodiments are merely provided to ensure that the disclosure of the present invention is complete and to provide a general understanding of the technical field to which the present invention pertains. It is provided to fully inform the skilled person of the scope of the present invention, and the present invention is only defined by the scope of the claims.

The terminology used herein is for describing embodiments and is not intended to limit the invention. As used herein, singular forms also include plural forms, unless specifically stated otherwise in the context. As used in the specification, “comprises” and/or “comprising” does not exclude the presence or addition of one or more other elements in addition to the mentioned elements. Like reference numerals refer to like elements throughout the specification, and “and/or” includes each and every combination of one or more of the referenced elements. Although “first”, “second”, etc. are used to describe various components, these components are of course not limited by these terms. These terms are merely used to distinguish one component from another. Therefore, it goes without saying that the first component mentioned below may also be a second component within the technical spirit of the present invention.

Unless otherwise defined, all terms (including technical and scientific terms) used in this specification may be used with meanings commonly understood by those skilled in the art to which the present invention pertains. Additionally, terms defined in commonly used dictionaries are not interpreted ideally or excessively unless clearly specifically defined.

First, the problems in the prior art described in the background are explained in more detail as follows.

1. Text-based approach: In the prior art, developers must write code based on text, which causes the inconvenience of having to remember complex commands and syntax and write each line grammatically. This reduces developer productivity and increases the likelihood of typos or grammatical errors.

2. Readability, reusability, and maintainability issues: In the prior art, code readability, reusability, and maintainability are often poor, so software development takes a significant amount of time and money. These problems become more serious as the project scale increases, and may result in additional costs due to maintenance difficulties.

3. Limitations of the visual programming environment: Some conventional technologies provide a visual programming environment, but this is mainly suitable for simple projects and may provide limited functionality or have scalability problems in complex projects. As a result, the higher the complexity of the project, the lower the development efficiency.

4. Limitations of template-based code generation tools: Since code generation tools in the prior art use a template-based method, developers may have limitations in modifying or expanding the code to suit their needs. Additionally, templates may have difficulty meeting requirements that differ from the creator's intentions, requiring developers to perform additional work.

5. Difficulty in productivity and collaboration: In the prior art, it is sometimes difficult for multiple developers to work on the same source code simultaneously. This can reduce collaboration efficiency and slow project progress due to source code conflicts and interaction issues.

These problems act as factors that limit the efficiency and flexibility of software development in the prior art. This makes development and maintenance of complex projects difficult, and may incur additional costs due to reduced productivity and code quality. As an alternative to this, the automatic stacked code generation system, server, and method based on tree structure information according to an embodiment of the present invention provide a method to efficiently create, modify, and maintain code during the software development process. By doing so, it reduces software development time and development costs and enables high-quality code generation.

In computer programming, source code consists of a series of computer instructions, and programmers implement the functions and operations of software by writing and managing source code. These processors are complex and time-consuming, and readability, reusability, and maintainability of code become important issues, especially in large-scale software projects.

One embodiment of the present invention provides a tool that allows software developers to effectively design the structure and logic of a program. The present invention creates software components, each node has a specific function or role, and the corresponding data is stored as information in the form of a tree structure. This generation method allows developers to visually understand the overall architecture of the software and easily identify and apply any necessary changes.

The present invention improves code reusability and modularity through a way to express interactions between nodes. This allows developers to write and modify code efficiently, ultimately reducing software development time and costs.

Additionally, the present invention can automatically generate source code for each node by utilizing a stacked code automatic generation algorithm. In this process, the developer defines the interactions between nodes, and the algorithm generates actual executable source code based on that information.

The features of the automatic stacked code generation system, server, and method based on tree structure information according to an embodiment of the present invention are as follows.

1. Providing a visual programming environment through a layered tree structure: The present invention displays software components in a layered tree structure so that developers can visually understand the software architecture. This tree structure clearly represents the relationships between the various modules and sub-modules of the program, and in this visualized environment, developers can understand the structure and logic of the program more intuitively and easily apply changes.

2. Support for high reusability and modularity: The method of representing the interaction between nodes in the tree structure contributes to increasing the reusability and modularity of the code. Each node represents an independent function, and these functions can also be utilized in other projects. This allows developers to use previously written modules in other projects, enable efficient code writing and modification, and reduce development time and costs.

3. Application of the stacked code automatic generation algorithm: The present invention applies the stacked code automatic generation algorithm that automatically generates the source code for each node of the tree structure to create executable code based on the function defined for each node of the tree. Generate source code. In the process of defining the functions and interactions of each node, developers can clearly specify program behavior, and the algorithm can automatically generate code based on this information.

4. Scalability and collaboration support: The present invention provides scalability regardless of the size and complexity of the project and has a structure suitable for collaboration between multiple developers. The tree structure and stacked code generation algorithm provide an environment where multiple developers can work on various modules at the same time and integrate them to complete a single program, which improves the productivity of the development team and speeds up project progress. It can be improved.

Through these features, the present invention can overcome the problems of the prior art and provide a method to increase the efficiency and flexibility of software development.

Hereinafter, the automatic stacked code generation system, server, and method based on tree structure information according to an embodiment of the present invention will be described in more detail with reference to each drawing.

Figure 1 is a diagram for explaining a stacked code automatic generation system 1 based on tree structure information according to an embodiment of the present invention. FIG. 2 is a diagram for explaining the user interface provided by the client terminal 200. Figure 3 is a block diagram of a stacked code automatic generation server 100 based on tree structure information according to an embodiment of the present invention.

The stacked code automatic generation system 1 according to an embodiment of the present invention includes a client terminal 200, a stacked code automatic generation server 100 (hereinafter referred to as server), and a database 300.

The client terminal 200 provides a user interface to the user. And, as shown in FIG. 2, tree structure information including structure information and logic information of the design target software is generated through the user interface, and the tree structure information is converted into a predetermined form (for example, JSON type) and stored on the server ( 100).

The user interface visually shows the user many of the functions needed when creating a program. Users can create and modify connections to the necessary functions among these layered functions, thereby defining the structure and logic of the program. Users can visually understand the structure of the program and effectively control the logic by adding, deleting, and moving individual nodes. Additionally, users can review the automatically generated code through the user interface and modify or extend it as needed. Meanwhile, the client terminal 200 may provide a user interface in the form of a web browser or desktop application.

The server 100 may include a communication module 110, memory 120, and processor 130.

The communication module 110 receives tree structure information including structure information and logic information of the converted design target software from the client terminal 200, and transmits the generated project and source code to the client terminal 200. This communication module 110 may include both a wired communication module and a wireless communication module. The wired communication module can be implemented as a power line communication device, telephone line communication device, home cable (MoCA), Ethernet, IEEE1294, integrated wired home network, and RS-485 control device. In addition, wireless communication modules include WLAN (wireless LAN), Bluetooth, HDR WPAN, UWB, ZigBee, Impulse Radio, 60GHz WPAN, Binary-CDMA, wireless USB technology and wireless HDMI technology, as well as 5G (5th generation communication) and LTE-A. It may be composed of modules to implement functions such as (long term evolution-advanced), LTE (long term evolution), and Wi-Fi (wireless fidelity).

The memory 120 stores a program for generating a project and source code based on tree structure information. Here, the memory 120 is a general term for non-volatile storage devices and volatile storage devices that continue to retain stored information even when power is not supplied. For example, memory 120 may include compact flash (CF) cards, secure digital (SD) cards, memory sticks, solid-state drives (SSD), and micro SD. This includes NAND flash memory such as cards, magnetic computer storage devices such as hard disk drives (HDD), and optical disc drives such as CD-ROM, DVD-ROM, etc. You can.

The processor 130 may execute software, such as a program, to control at least one other component (e.g., hardware or software component) of the multi-target detection system 100, and may perform various data processing or calculations. .

The processor 130 generates structure information from tree structure information based on a stacked code automatic generation algorithm. Then, based on the structure information, a project and source code corresponding to the design target software are generated and transmitted to the client terminal 200.

Additionally, the server 100 may store data related to the generated code in the database 300 or, if necessary, transmit a query to search and modify it to the database 300.

The database 300 stores and manages various data such as tree structure information, user information and settings information, and project metadata. The server 100 can create or modify codes using data stored in the database 300, and search and return information according to user requests. The database 300 stores history information on projects created by users, allowing users to review or restore previous work.

Figure 4 is a diagram for explaining tree structure information in an embodiment of the present invention.

In one embodiment of the present invention, the tree structure information includes a project node, which is the highest node representing the software to be designed, a project setting node and a class node, which are lower nodes of the project node, and a release node and debug node, which are lower nodes of the project setting node. Wow, it can include a header file node and a source file node, which are child nodes of the class node.

First, the project, the top node, is the top node representing the software to be designed, and the project node may include several class nodes below it. These class nodes define the overall structure and functionality of the project.

The project settings node manages the overall settings of the project. This includes the project name, version information, programming language used, compilation options, etc. These settings are applied to the entire project and serve to define the characteristics of the software being developed.

A class node is a core component in object-oriented programming and represents a bundle of code that performs a specific function. Class nodes contain methods and properties, which are expressed as header files and source files, respectively. Classes play a role in increasing modularity and reusability of software.

The release node manages the settings used when the program is actually distributed. These settings may include code optimization options, options for removing debug information, and more. Release settings are responsible for creating the executable file that the end user runs.

The debug node manages settings used when developing and testing programs. Options to include debug information, additional logging options, etc. can be included in the debug node. Debug settings facilitate the process of finding and correcting program errors.

Header file nodes are mainly used in languages such as C++ and include class declarations, function prototypes, macros, etc. In other words, the header file node defines the contents of each header file.

Source file nodes mainly include class definitions, function implementations, etc., and include the actual code of the program. in other words. The source file node defines what code each source file contains.

In this way, the user can visually design the structure and logic of the design target software through the provided user interface, and this is stored as tree structure information. Tree structure information expresses the overall architecture of the software being designed and the relationship between each function, module, or class, where each node is responsible for a specific function or role, and the user can specify and modify the details and properties of the nodes through the user interface. You can.

The client terminal 200 converts the tree structure information into JSON type to transmit it to the server 100. Figures 5a to 5c are diagrams showing an example of converting tree structure information to JSON type. Figure 5a is a project tree structure converted to JSON type, and Figure 5b is a header file tree structure converted to JSON type. , Figure 5c shows the source file tree structure converted to JSON type. The JSON format is a widely used format for efficient storage and transmission of data, and represents data using a hierarchical structure and key-value pairs. Information entered in the user interface is serialized in JSON format and transmitted to the server 100. At this time, the reason why the JSON format was chosen is because of its flexibility, readability, and versatility.

When the server 100 receives tree structure information converted to JSON type, it generates structure information from the tree structure information based on a stacked code automatic generation algorithm. That is, the server 100 determines a stacked code structure based on the corresponding information and metadata pre-stored in the server 100, and executes a code generation algorithm according to each node and relationship.

Figure 6 is a diagram showing structure information in one embodiment of the present invention. Figure 7 is a diagram for explaining a stacked code conversion process of tree structure information in an embodiment of the present invention.

Specifically, the server 100 may first create a project template data structure (ProjectTemplateData) based on JSON type tree structure information. The project template data structure can include the basic information of the project and all setting information included in the project. In other words, the project template data structure can extract the project name (prjName), supported platform version (platformVersion), and project settings information (Configurations) from JSON data and store them in the structure.

- prjName: This string is an item that stores the name of the project.

- platformVersion: Indicates the supported platform version of the project and can include, for example, Win32 and x64.

- Configurations: This vector contains instances of the project configuration data structure (ProjectConfigData) containing detailed information about each configuration of the project.

Next, the server 100 may create a project configuration data structure (ProjectConfigData) based on the project configuration information included in the project template data structure. The project settings data structure may include the name of the project setting corresponding to the project, the platform of the project setting, the path of header files and source files that should be included in the project, additional directory paths, project dependencies, and preprocessing information.

- name: Saves the name of the project settings (e.g. Debug, Release).

- platform: Saves the platform (e.g. Win32, x64, etc.) corresponding to the project settings.

- headerPaths, sourcePaths: Stores the paths of header files and source files that should be included in the project.

- addIncDirectories, addLibDirectories, addDependencies, preprocDefinitions: Stores information related to the project's dependencies, such as additional include directories, library directories, dependencies, and preprocessing definitions.

Additionally, the server 100 may generate a class template data structure (ClassTemplateData) and a function template data structure (FunctionTemplateData) based on class and function information extracted from JSON-type tree structure information.

The class template data structure may include the name of the class, the type of member variable of each class, annotation information for the name and corresponding variable, and information on template data of member functions, initialization functions, and termination functions to be defined within the class.

- className: Stores the name of the class.

- mVariableTypes, mVariableNames, mVariableComments: Stores the type and name of member variables of each class and comment information for the variables.

- mFunctions, initFunctions, exitFunctions: Stores template data of member functions, initialization functions, and exit functions that must be defined within the class.

The function template data structure includes the name of the function, the type and name of the parameters stored in the form of a tuple, the name of the function return type and return value storage variable, the exception handling method according to the return value of the initialization or termination statement, the contents of the function comment, and the initialization. Alternatively, the termination statement may include the name of the member variable object required when calling and additional setting value information of the function. In other words, the function template data structure provides detailed information about the function template.

- funcName: Stores the name of the function.

- funcParams: Stores the types and names of function parameters in tuple form.

- rtnType and rtnValue: Stores the return type of the function and the name of the return value storage variable.

- errCheckType: Stores the exception handling method according to the return value of the initialization or termination statement.

- codeComment: Stores comments about the function.

- mObj: Stores the name of the member variable object needed when called in initialization or termination statements.

- advInfo: Stores information about additional setting values of the function.

In addition, the server 100 may create an advanced information set structure (AdvancedInfoSet) that includes additional settings required when initializing functions.

- advInfoVariable: Saves the name of the member variable to store the setting value.

- advInfoType, advInfoName, advInfoValue: Stores the type, name, and user setting values of additional setting values required during initialization.

Additionally, in one embodiment of the present invention, the server 100 can determine an error handling method according to the return value of the function through the ErrType enumeration item defined in the function template data structure. For example, when a function returns an error, the server 100 can select various processing methods such as output, repeat performance, return an error, or ignore the error.

Afterwards, the server 100 can automatically generate an executable project and source code corresponding to the design target software based on the structure information. The generated projects and code are tailored to the programming language and platform specified by the user, and are accurately structured according to tree structure information. The source code generated in this way can be compiled and executed immediately, and can be further modified or expanded by the user if necessary. For reference, Figure 8 shows an example of the result of generating a header file based on structure information, and Figures 9A and 9B show an example of the result of generating a source file based on structure information.

Hereinafter, with reference to FIG. 10, a method of automatically generating a stacked code performed in the server 100 according to an embodiment of the present invention will be described.

Figure 10 is a flowchart of a method for automatically generating a stacked code performed in the server 100 according to an embodiment of the present invention.

First, tree structure information in a predetermined form including structural information and logic information of the software to be designed is received from the client terminal 200 (S110).

Next, structure information is generated from the tree structure information based on a stacked code automatic generation algorithm (S120).

Next, a project and source code corresponding to the design target software are generated based on the structure information (S130).

Next, the generated project and source code are transmitted to the client terminal 200 (S140).

Meanwhile, in the above description, steps S110 to S140 may be further divided into additional steps or combined into fewer steps, depending on the implementation of the present invention. Additionally, some steps may be omitted or the order between steps may be changed as needed. In addition, even if other omitted content, the content described in FIGS. 1 to 9B and the content described in FIG. 10 can be mutually applied.

The method of automatically generating a stacked code according to an embodiment of the present invention described above may be implemented as a program (or application) and stored in a medium in order to be executed in conjunction with a computer, which is hardware.

The above-mentioned program is C, C++, JAVA, Ruby, and It may include code encoded in a computer language such as machine language. These codes may include functional codes related to functions that define the necessary functions for executing the methods, and include control codes related to execution procedures necessary for the computer's processor to execute the functions according to predetermined procedures. can do. In addition, these codes may further include memory reference-related codes that indicate at which location (address address) in the computer's internal or external memory additional information or media required for the computer's processor to execute the above functions should be referenced. there is. In addition, if the computer's processor needs to communicate with any other remote computer or server to execute the above functions, the code uses the computer's communication module to determine how to communicate with any other remote computer or server. It may further include communication-related codes regarding whether communication should be performed and what information or media should be transmitted and received during communication.

The storage medium refers to a medium that stores data semi-permanently and can be read by a device, rather than a medium that stores data for a short period of time, such as a register, cache, or memory. Specifically, examples of the storage medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage device, etc., but are not limited thereto. That is, the program may be stored in various recording media on various servers that the computer can access or on various recording media on the user's computer. Additionally, the medium may be distributed to computer systems connected to a network, and computer-readable code may be stored in a distributed manner.

The description of the present invention described above is for illustrative purposes, and those skilled in the art will understand that the present invention can be easily modified into other specific forms without changing the technical idea or essential features of the present invention. will be. Therefore, the embodiments described above should be understood in all respects as illustrative and not restrictive. For example, each component described as unitary may be implemented in a distributed manner, and similarly, components described as distributed may also be implemented in a combined form.

The scope of the present invention is indicated by the claims described below rather than the detailed description above, and all changes or modified forms derived from the meaning and scope of the claims and their equivalent concepts should be construed as being included in the scope of the present invention. do.

1: Stacked code automatic generation system
100: Stacked code automatic generation server
110: Communication module
120: memory
130: processor
200: client terminal
300: database

Claims (19)

In a method performed by a computer,
Receiving tree structure information in a predetermined form including structure information and logic information of the design target software from a client terminal;
generating structure information from the tree structure information based on a stacked automatic code generation algorithm;
generating a project and source code corresponding to the design target software based on the structure information; and
Including transmitting the generated project and source code to the client terminal,
The tree structure information includes a project node, which is the highest node representing the design target software,
A project setting node and a class node that are sub-nodes of the project node,
A method of automatically generating a stacked code based on tree structure information, including a release node and a debug node that are lower nodes of the project setting node, and a header file node and a source file node that are lower nodes of the class node.
According to paragraph 1,
The step of receiving tree structure information in a predetermined form including structure information and logic information of the design target software from the client terminal,
A method of automatically generating a stacked code based on tree structure information, wherein the tree structure information converted to JSON type is received from the client terminal.
delete According to paragraph 1,
The step of generating structure information from the tree structure information based on the stacked automatic code generation algorithm,
generating a project template data structure based on the tree structure information;
generating a project setting data structure based on project setting information included in the project template data structure; and
A method of automatically generating a stacked code based on tree structure information, including generating a class template data structure and a function template data structure based on class and function information extracted from the tree structure information.
According to paragraph 4,
The step of creating a project template data structure based on the tree structure information is,
A method of automatically generating a stacked code based on tree structure information, which generates a project template data structure including the name of the project, the supported platform version, and the project setting information.
According to paragraph 4,
The step of creating a project settings data structure based on the project settings information included in the project template data structure is:
Creating the project settings data structure including the name of the project settings corresponding to the project, the platform of the project settings, the path to the header file and source file to be included in the project, additional additional include directories, library directories, and project dependency information. A method for automatically generating stacked codes based on tree structure information. According to paragraph 4,
The step of generating a class template data structure and a function template data structure based on the class and function information extracted from the tree structure information includes:
Creating the class template data structure including the name of the class, member variable type of each class, annotation information for the name and corresponding variable, and template data information of member functions, initialization functions, and termination functions to be defined in the class. A method for automatically generating layered code based on tree structure information.
According to paragraph 4,
The step of generating a class template data structure and a function template data structure based on the class and function information extracted from the tree structure information includes:
The name of the function, the type and name of the parameter stored in tuple form, the name of the function return type and return value storage variable, the exception handling method according to the return value of the initialization or termination statement, the contents of the function comment, and the call in the initialization or termination statement. A method of automatically generating a stacked code based on tree structure information, which generates the function template data structure including the name of the member variable object and additional setting value information of the function.
According to paragraph 4,
The step of generating structure information from the tree structure information based on the stacked automatic code generation algorithm,
A method of automatically generating layered code based on tree-structured information, including the step of creating a high-level information set structure containing additional settings required for function initialization.
A communication module that receives tree structure information in a predetermined form including structural information and logic information of the design target software from a client terminal and transmits the generated project and source code to the client terminal;
A memory storing a program for generating the project and source code based on the tree structure information, and
By executing the program stored in the memory, structure information is generated from the tree structure information based on a stacked automatic code generation algorithm, and a project and source code corresponding to the design target software are generated based on the structure information. Includes a processor,
The tree structure information includes a project node, which is the highest node representing the design target software,
A project setting node and a class node that are sub-nodes of the project node,
A stacked code automatic generation server based on tree structure information, including a release node and a debug node that are lower nodes of the project setting node, and a header file node and a source file node that are lower nodes of the class node.
According to clause 10,
The communication module is a stacked code automatic generation server based on tree structure information that receives the tree structure information converted to JSON type from the client terminal.
delete According to clause 10,
The processor generates a project template data structure based on the tree structure information, generates a project setting data structure based on project setting information included in the project template data structure, and classes and functions extracted from the tree structure information. A layered code automatic generation server based on tree structure information that generates class template data structures and function template data structures based on the information.
According to clause 13,
The automatic stacked code generation server based on tree structure information, wherein the processor generates a project template data structure including the name of the project, a supported platform version, and the project setting information.
According to clause 13,
The processor generates the project setting data structure including the name of the project setting corresponding to the project, the platform of the project setting, the path of the header file and source file to be included in the project, an additional additional include directory, a library directory, and project dependency information. A server that automatically generates layered code based on tree structure information.
According to clause 13,
The processor generates the class template data including the name of the class, the type of member variable of each class, the name and annotation information for the corresponding variable, and the template data of the member function, initialization function, and termination function to be defined in the class. A layered code automatic generation server based on tree structure information that generates structures.
According to clause 13,
The processor stores the name of the function, the type and name of the parameter stored in the form of a tuple, the name of the function return type and return value storage variable, the exception handling method according to the return value of the initialization or termination statement, the contents of the function comment, and the initialization or termination. A stacked code automatic generation server based on tree structure information that generates the function template data structure including the name of the member variable object required when calling from the syntax and additional setting value information of the function.
According to clause 13,
The automatic stacked code generation server based on tree structure information, wherein the processor generates an advanced information set structure including additional settings required when initializing functions.
delete