Compilation method, device, computer equipment and readable storage medium

Abstract

The present disclosure provides a compilation method, device, computer equipment and readable storage medium, wherein the method includes: establishing a configuration file when building a target project; compiling source code files corresponding to multiple sub-projects according to the configuration file to obtain target files corresponding to multiple sub-projects; performing preset processing on multiple sub-projects to obtain a project file of the target project. The disclosed embodiment reduces the workload required when writing configuration files, and once a source code file or sub-project is to be added or deleted in a project, it is only necessary to modify the configuration file corresponding to the target project, thereby reducing the time required to modify the configuration file, improving the efficiency of project construction, and reducing costs.

Description

Technical Field

[0001] The present disclosure relates to the technical field of software development, and in particular to a compilation method, apparatus, computer device, and readable storage medium. Background Art

[0002] Project building tools are indispensable tools when developing software projects. For example, cross-platform installation (compilation) tools (cross platform make, CMake) and installation (compilation) tools (Make) are tools used when developing C / C++ software projects. They can assist developers in compiling, linking, and packaging source code written in C / C++, thereby improving development efficiency.

[0003] In the related art, the method of using project construction tools to construct projects has the problems of low efficiency and high cost. Summary of the invention

[0004] The embodiments of the present disclosure at least provide a compilation method, apparatus, computer equipment, and readable storage medium.

[0005] In a first aspect, an embodiment of the present disclosure provides a compilation method, including:

[0006] Establishing a configuration file when building a target project; wherein the configuration file includes at least one of the following: subproject identifiers corresponding to the plurality of subprojects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to the plurality of subprojects, dependency information between the plurality of subprojects, and compilation parameters corresponding to the plurality of subprojects;

[0007] According to the configuration file, source code files corresponding to the plurality of sub-projects are compiled to obtain target files corresponding to the plurality of sub-projects;

[0008] The target files of the plurality of sub-projects are preset to obtain the project file of the target project.

[0009] In this way, the workload required for writing configuration files can be reduced. Once you need to add or delete source code files or sub-projects in the project, you only need to modify the configuration files corresponding to the target project, which reduces the time required to modify the configuration files, improves the efficiency of project construction, and reduces costs.

[0010] In an optional implementation, the configuration file includes: dependency information between the plurality of sub-projects, and the source code files of the sub-projects include: a first source code file that is dependent on other sub-projects, and / or a second source code file that is not dependent on other sub-projects;

[0011] The source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects, including:

[0012] For each of the plurality of subprojects, in response to determining that each of the subprojects corresponds to a dependent subproject based on the dependency information, obtaining a target first source code file that each of the subprojects depends on from a first source code file corresponding to the dependent subproject;

[0013] The target first source code file that each sub-project depends on and the source code file corresponding to each sub-project are compiled to obtain the target file corresponding to each sub-project.

[0014] In this way, analysis is performed based on the dependency information in the configuration file, making it easier to obtain the corresponding target source code file.

[0015] In an optional implementation manner, the dependency relationship information includes: sub-project identifiers of dependent sub-projects corresponding to the plurality of sub-projects, and dependent source code file identifiers;

[0016] The obtaining of the target first source code file that each sub-project depends on includes:

[0017] Generate an access path to the target first source code file based on the subproject identifier of the dependent subproject corresponding to each subproject, the dependent source code file identifier, and the organization form of the source code files of the plurality of subprojects;

[0018] Based on the access path, a target first source code file that each sub-project depends on is obtained.

[0019] In this way, the corresponding source code file can be obtained more conveniently through the determined access path.

[0020] In an optional implementation manner, the organization form of the source code files of the plurality of sub-projects includes:

[0021] The source code files corresponding to different sub-projects are stored in different folders, and for each sub-project, in response to each sub-project including a first source code file, the first source code file is stored in a first type of sub-folder in the folder of the corresponding sub-project; in response to each sub-project including a second source code file, the second source code file is stored in a second type of sub-folder in the folder of the corresponding sub-project.

[0022] In this way, by storing different source code files in different types of subfolders, it is easy to implement the calling process of the sub-project source code files.

[0023] In an optional implementation, the configuration file includes: second type information of compilation results corresponding to the plurality of sub-projects respectively, and the source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects respectively, including:

[0024] For each subproject among the multiple subprojects, based on the second type information of the compilation result corresponding to each subproject, the source code file of each subproject is compiled to obtain a target file matching the type information of the compilation result corresponding to each subproject.

[0025] In this way, the source code file can be compiled based on the target type, so that the compilation process can be accurately performed to obtain the target file.

[0026] In an optional implementation, the configuration file includes: dependency information between the plurality of sub-projects, and the source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects, including:

[0027] Determining a construction order of the plurality of sub-projects based on dependency information between the plurality of sub-projects included in the configuration file;

[0028] According to the construction order of the multiple sub-projects, the source code files corresponding to the multiple sub-projects are compiled in sequence to obtain the target files corresponding to the multiple sub-projects.

[0029] In this way, compilation is performed based on a determined build order, so that the compilation process can be completed more accurately.

[0030] In an optional implementation manner, determining the construction order of the plurality of sub-projects based on the dependency information between the plurality of sub-projects included in the configuration file includes:

[0031] Based on the dependency information between the multiple sub-items included in the configuration file, establishing a topological structure corresponding to the multiple sub-items;

[0032] Based on the topological structure, a construction order of the plurality of sub-projects is determined.

[0033] In an optional implementation, the configuration file includes: first type information of the compilation result corresponding to the target project, and the preset processing of the target files of the plurality of sub-projects to obtain the project file of the target project includes:

[0034] According to the preset processing mode indicated by the first type information of the target project, the target files of the plurality of sub-projects are preset processed to obtain the project file of the target project; wherein the preset processing is associated with the first type information of the compilation result of the target project.

[0035] In this way, the target file is processed based on the target type, thereby accurately performing the processing and obtaining the project file of the target project.

[0036] In an optional implementation, the type information includes any one of the following:

[0037] Dynamic databases, static databases, executable files, and header files;

[0038] The type information includes: first type information and / or second type information.

[0039] In an optional implementation manner, the first type of information includes: a dynamic database, and the preset processing method indicated by the first type of information includes: packaging the target file into a dynamic database;

[0040] The first type of information includes: a static database, and the preset processing method indicated by the first type of information includes: packaging the target file into a static database;

[0041] The first type of information includes: an executable file, and the preset processing method indicated by the first type of information includes: linking the target file into an executable file;

[0042] The first type of information includes: a header file, and the preset processing method indicated by the first type of information includes: copying the target file to a target output folder.

[0043] In this way, the processing process for the target project can be completed in a targeted manner based on different types of information.

[0044] In a second aspect, an embodiment of the present disclosure provides a compiling device, including:

[0045] A building module, used to build a configuration file when building a target project; wherein the configuration file includes at least one of the following: sub-project identifiers corresponding to multiple sub-projects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to multiple sub-projects, dependency information between multiple sub-projects, and compilation parameters corresponding to multiple sub-projects;

[0046] A compiling module, used to compile source code files corresponding to the plurality of sub-projects respectively according to the configuration file, to obtain target files corresponding to the plurality of sub-projects respectively;

[0047] The processing module is used to perform preset processing on the target files of the plurality of sub-projects to obtain the project file of the target project.

[0048] In an optional implementation, the configuration file includes: dependency information between the plurality of sub-projects, and the source code files of the sub-projects include: a first source code file that is dependent on other sub-projects, and / or a second source code file that is not dependent on other sub-projects;

[0049] The compilation module includes:

[0050] An acquiring unit is configured to acquire, for each of the plurality of subprojects, a target first source code file that each subproject depends on from a first source code file corresponding to the dependent subproject in response to determining that each subproject corresponds to a dependent subproject based on the dependency relationship information;

[0051] The first compiling unit is used to compile the target first source code file that each sub-project depends on and the source code file corresponding to each sub-project to obtain the target file corresponding to each sub-project.

[0052] In an optional implementation manner, the dependency relationship information includes: sub-project identifiers of dependent sub-projects corresponding to the plurality of sub-projects, and dependent source code file identifiers;

[0053] The acquisition unit is specifically used for:

[0054] Generate an access path to the target first source code file based on the subproject identifier of the dependent subproject corresponding to each subproject, the dependent source code file identifier, and the organization form of the source code files of the plurality of subprojects;

[0055] Based on the access path, a target first source code file that each sub-project depends on is obtained.

[0056] In an optional implementation manner, the organization form of the source code files of the plurality of sub-projects includes:

[0057] The source code files corresponding to different sub-projects are stored in different folders, and for each sub-project, in response to each sub-project including a first source code file, the first source code file is stored in a first type of sub-folder in the folder of the corresponding sub-project; in response to each sub-project including a second source code file, the second source code file is stored in a second type of sub-folder in the folder of the corresponding sub-project.

[0058] In an optional implementation manner, the configuration file includes: second type information of compilation results corresponding to the plurality of sub-projects respectively, and the compilation module is specifically used for:

[0059] For each subproject among the multiple subprojects, based on the second type information of the compilation result corresponding to each subproject, the source code file of each subproject is compiled to obtain a target file matching the type information of the compilation result corresponding to each subproject.

[0060] In an optional implementation manner, the configuration file includes: dependency information between the plurality of sub-projects, and the compilation module further includes:

[0061] A determining unit, configured to determine a construction order of the plurality of sub-projects based on dependency information between the plurality of sub-projects included in the configuration file;

[0062] The second compiling unit is used to compile the source code files respectively corresponding to the multiple sub-projects in sequence according to the construction order of the multiple sub-projects to obtain the target files respectively corresponding to the multiple sub-projects.

[0063] In an optional implementation manner, the determining unit is specifically configured to:

[0064] Based on the dependency information between the multiple sub-items included in the configuration file, establishing a topological structure corresponding to the multiple sub-items;

[0065] Based on the topological structure, a construction order of the plurality of sub-projects is determined.

[0066] In an optional implementation manner, the configuration file includes: first type information of the compilation result corresponding to the target project, and the processing module is specifically used to:

[0067] According to the preset processing mode indicated by the first type information of the target project, the target files of the plurality of sub-projects are preset processed to obtain the project file of the target project; wherein the preset processing is associated with the first type information of the compilation result of the target project.

[0068] In an optional implementation, the type information includes any one of the following:

[0069] Dynamic databases, static databases, executable files, and header files;

[0070] The type information includes: first type information and / or second type information.

[0071] In an optional implementation manner, the first type of information includes: a dynamic database, and the preset processing method indicated by the first type of information includes: packaging the target file into a dynamic database;

[0072] The first type of information includes: a static database, and the preset processing method indicated by the first type of information includes: packaging the target file into a static database;

[0073] The first type of information includes: an executable file, and the preset processing method indicated by the first type of information includes: linking the target file into an executable file;

[0074] The first type of information includes: a header file, and the preset processing method indicated by the first type of information includes: copying the target file to a target output folder.

[0075] In a third aspect, an embodiment of the present disclosure further provides a computer device, comprising: a processor, a memory and a bus, wherein the memory stores machine-readable instructions executable by the processor, and when the computer device is running, the processor and the memory communicate via the bus, and when the machine-readable instructions are executed by the processor, the steps of the above-mentioned first aspect, or any possible implementation of the first aspect are performed.

[0076] In a fourth aspect, an embodiment of the present disclosure further provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, the steps of the above-mentioned first aspect, or any possible implementation of the first aspect are executed.

[0077] For a description of the effects of the above-mentioned compilation device, computer equipment, and computer-readable storage medium, please refer to the description of the above-mentioned compilation method, which will not be repeated here.

[0078] The embodiments of the present disclosure provide a compilation method, an apparatus, a computer device, and a readable storage medium. A configuration file is established for a target project instead of for each source code file. The target project is processed using the configuration file corresponding to the target project. This reduces the workload required when writing the configuration file. Once a source code file or a sub-project is to be added or deleted in the project, only the configuration file corresponding to the target project needs to be modified. This reduces the time required to modify the configuration file, improves the efficiency of project construction, and reduces costs.

[0079] In order to make the above-mentioned objectives, features and advantages of the present disclosure more obvious and easy to understand, preferred embodiments are specifically cited below and described in detail with reference to the attached drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0080] In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the following is a brief introduction to the drawings required for use in the embodiments. The drawings herein are incorporated into the specification and constitute a part of the specification. These drawings illustrate embodiments consistent with the present disclosure and are used together with the specification to illustrate the technical solutions of the present disclosure. It should be understood that the following drawings only illustrate certain embodiments of the present disclosure and should not be regarded as limiting the scope. For ordinary technicians in this field, other relevant drawings can also be obtained based on these drawings without creative work.

[0081] Figure 1 A flowchart of a compilation method provided by an embodiment of the present disclosure is shown;

[0082] Figure 2 A schematic diagram of a compiling device provided by an embodiment of the present disclosure is shown;

[0083] Figure 3 A specific schematic diagram of a compiling module in the compiling device provided in an embodiment of the present disclosure is shown;

[0084] Figure 4 A specific schematic diagram of another compiling module in the compiling device provided in an embodiment of the present disclosure is shown;

[0085] Figure 5 A schematic diagram of a computer device provided by an embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0086] In order to make the purpose, technical scheme and advantages of the embodiments of the present disclosure clearer, the technical scheme in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are only part of the embodiments of the present disclosure, rather than all of the embodiments. The components of the embodiments of the present disclosure generally described and shown in the drawings here can be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present disclosure provided in the drawings is not intended to limit the scope of the present disclosure for protection, but merely represents the selected embodiments of the present disclosure. Based on the embodiments of the present disclosure, all other embodiments obtained by those skilled in the art without making creative work belong to the scope of protection of the present disclosure.

[0087] Through research, it is found that a software project usually includes multiple sub-projects; before building a software project, the source code files corresponding to the multiple sub-projects are saved in folders corresponding to the sub-projects, and for each sub-project, a configuration file corresponding to the sub-project is written, and the configuration file and the source code file corresponding to the sub-project are saved in the same folder; in the configuration file, the build process required for each source code file in the sub-project during the build process is saved; when using the project build tool to build a software project, for each sub-project, the source code file corresponding to the sub-project is built according to the configuration file in the folder corresponding to the sub-project.

[0088] However, due to the large number of source code files or sub-projects, a corresponding number of configuration files need to be written, which consumes a large amount of work and takes a long time, resulting in low efficiency and high cost in the construction process of the software project.

[0089] Furthermore, the interdependencies between sub-projects are complex. Once you add or delete a source code file or a sub-project in a project, you need to modify the corresponding configuration files and the source code files with dependencies or the configuration files corresponding to the sub-projects. The modification process of multiple configuration files itself requires a lot of time and human resources, and the complex dependencies make the modification process of the configuration files more complicated, resulting in low project construction efficiency and high cost.

[0090] Based on the above research, the present disclosure provides a compilation method, which establishes a configuration file for the target project instead of establishing a configuration file for each source code file, and uses the configuration file corresponding to the target project to process the target project. This reduces the workload required when writing the configuration file, and once you need to add or delete a source code file or sub-project in the project, you only need to modify the relevant configuration information in the configuration file corresponding to the target project, which reduces the time required to modify the configuration file, improves the efficiency of software project construction, and reduces costs.

[0091] The defects existing in the above solutions are the results obtained by the inventor after practice and careful research. Therefore, the discovery process of the above problems and the solutions proposed by the present disclosure for the above problems below should be the contributions made by the inventor to the present disclosure during the disclosure process.

[0092] It should be noted that similar reference numerals and letters denote similar items in the following drawings, and therefore, once an item is defined in one drawing, further definition and explanation thereof is not required in subsequent drawings.

[0093] The compiling method provided in the embodiment of the present disclosure can be used for software development based on C / C++ language, such as development of application programs, systems, interfaces, etc. In addition, it can also be used for software development in other object-oriented programming languages.

[0094] To facilitate understanding of the present embodiment, a compilation method disclosed in the embodiment of the present disclosure is first introduced in detail. The execution subject of the compilation method provided in the embodiment of the present disclosure is generally a computer device with certain computing capabilities, and the computer device includes, for example: a terminal device or a server or other processing device, and the terminal device may be a user equipment (UE), a mobile device, a user terminal, a terminal, etc. In some possible implementations, the compilation method may be implemented by a processor calling a computer-readable instruction stored in a memory.

[0095] The compilation method provided by the embodiment of the present disclosure is described below.

[0096] See also Figure 1 As shown, Figure 1 This is a flowchart of a compilation method provided by an embodiment of the present disclosure, the method comprising steps S101 to S103, wherein:

[0097] S101: Create a configuration file for building a target project.

[0098] In a specific implementation, the configuration file includes at least one of the following: sub-project identifiers corresponding to the multiple sub-projects of the target project, first type information of the compilation results corresponding to the target project, second type information of the compilation results corresponding to the multiple sub-projects, dependency information between the multiple sub-projects, and compilation parameters corresponding to the multiple sub-projects.

[0099] The compilation method provided by the embodiment of the present disclosure can be applied to environments with script execution such as UNIX and Windows. When executing the compilation method, a script can be written in advance, and the compilation method is executed by executing the script.

[0100] The target project includes multiple sub-projects, and there are certain dependencies between the sub-projects.

[0101] The target project is the project corresponding to the software program to be generated, which includes, for example, executable files for installing applications, or library files for storing data, for example, .exe files in the installation package before application A is installed, or library files that provide data support for other applications.

[0102] A target project may include multiple sub-projects. Sub-projects are, for example, multiple projects obtained by dividing the target project according to functions, etc. They include, for example, source code files and other parameter files.

[0103] Dependency refers to the calling relationship between multiple sub-projects. For example, when compiling the source code file of the sub-project corresponding to the executable file, it is often necessary to call part of the source code file of the database file, etc. It can also include the need to call part of the source code file in the B database when generating the A database, etc., thereby establishing the dependency relationship between multiple sub-projects.

[0104] The construction process of the target project is based on the multiple sub-projects included in the target project and the configuration file. By compiling each sub-project, the target files corresponding to each sub-project are obtained, and then the target files are linked, packaged, copied, etc. to complete the construction of the target project.

[0105] For example, the target project is a library management system, and the sub-projects include: book management system, user management system, book lending system, etc.

[0106] In the disclosed embodiment, the configuration file is a configuration file for the target project and there is only one configuration file globally. The configuration file includes configuration information for the target project and each sub-project.

[0107] The configuration information includes, for example, at least one of the following a1 to a5:

[0108] a1: sub-project identifiers corresponding to the multiple sub-projects of the target project.

[0109] The sub-project identifiers corresponding to the multiple sub-projects may be the name, character code, number, etc. of each sub-project. Here, for easy access, the sub-project identifier in the configuration file may be the same as the name of the sub-project folder where the sub-project is located.

[0110] In this way, when compiling a subproject, the subproject identifier of the subproject can be directly read from the configuration file, and based on the subproject identifier, the folder corresponding to the subproject identifier can be determined, and then the source code file corresponding to the subproject can be read from the folder and compiled.

[0111] The organization of the source code files of the sub-projects includes, for example: building a main folder for the target project; the relevant source code files corresponding to each sub-project can be stored in a sub-project folder, and all sub-project folders are stored in the main folder, and the sub-project folder no longer contains folders corresponding to the sub-projects at the next level. The purpose is to unify the organization of the source code files of multiple sub-projects in the target project, so that it is easy to know which source code files each sub-project contains. Because if the source code files of multiple sub-projects are mixed in one folder, or there are nested folders between different sub-projects, it is necessary to clearly specify all the source code files included for each sub-project, which is not only a huge workload, but also easy to cause compilation confusion, etc., affecting the construction process, etc.

[0112] a2: first type information of the compilation result corresponding to the target project.

[0113] The first type information is used to indicate the type of the target project, for example, including any of the following: a dynamic database, a static database, an executable file, and a header file.

[0114] The dynamic database (DLL) is an executable file that serves as a shared function library. The dynamic database provides a method for a process to call functions that do not belong to its executable code. Specifically, the executable code of the function is located in a dynamic database, which contains one or more functions that have been compiled, linked, and stored separately from the processes that use them. The dynamic database also helps to share data and resources. Multiple applications can access the contents of a single dynamic database copy in memory at the same time.

[0115] The static database means that in the application, there are some common codes that need to be used repeatedly, so these codes are compiled into "library" files; in the linking step, the connector will obtain the required code from the library file and copy it to the static library in the generated executable file.

[0116] The executable file, with an extension of .exe, refers to a file that can be loaded and executed by an operating system. In different operating system environments, the presentation of executable programs is different.

[0117] The header file is a carrier file containing function and data interface declarations, and is mainly used to store program declarations, while the definition file is used to store program implementations. Generally speaking, each C++ / C program is usually composed of a header file and a definition file.

[0118] a3: second type information of the compilation results respectively corresponding to the plurality of sub-items.

[0119] The second type information is used to indicate the type of the corresponding sub-item, for example, including any one of the following: a dynamic database, a static database, an executable file, and a header file.

[0120] The second type of information is similar to the first type of information described above and will not be described in detail here.

[0121] a4: Dependency information between the multiple sub-projects.

[0122] The dependency information between the multiple sub-projects includes: the calling relationship between the multiple sub-projects, for example, sub-project A calls certain functions of sub-project B, that is, sub-project A depends on sub-project B.

[0123] In the embodiment of the present disclosure, the dependency relationship information includes: sub-project identifiers of dependent sub-projects corresponding to the plurality of sub-projects respectively, and dependent source code file identifiers.

[0124] In one possible implementation, multiple subprojects do not support circular dependencies. There are three reasons why circular dependencies are not supported: a. Symbol-cannot-be-found errors may occur during the linking phase, which is determined by compilation tools such as the GNU Compiler Collection (GCC); b. The circularly dependent code itself is an unreasonable design; c. Topological sorting cannot be performed, that is, the order in which multiple subprojects are built cannot be determined. Correspondingly, the source code file identifiers that multiple subprojects depend on are the source code file identifiers of the target dependencies in the multiple source code information included in the dependent subprojects included in the configuration information.

[0125] a5: compilation parameters corresponding to the plurality of sub-items respectively.

[0126] In the disclosed embodiment, the compilation parameters corresponding to the plurality of sub-projects may include parameter information for assisting in completing the compilation process of the sub-projects, such as whether to add debugging information, optimization options, reference folders, etc.

[0127] In a possible embodiment, the project and each sub-project support executing additional scripts before and after building to achieve personalized building requirements, such as machine-generated code (protoc), etc., which will not be described in detail here.

[0128] In the disclosed embodiment, for the case where the configuration file includes: dependency information between multiple sub-projects, the source code file of the sub-project includes: a first source code file that is relied upon by other sub-projects, and / or a second source code file that is not relied upon by other sub-projects. That is, the file organization form of each sub-project folder in the project folder needs to distinguish between sub-project files that need to be referenced by other sub-projects and sub-project files that are not referenced by other sub-projects. For example, for a sub-project that is output as a static library, the header files that need to be referenced externally are placed in the include file (includefile, inc) folder, and the source code files within the project and the header files that are not referenced externally are placed in the resource code file (Source Code File, src) folder. In this way, it is more convenient to identify the sub-projects and sub-project folders that are relied upon and not relied upon, so that the sub-projects that need to be relied upon can be called, and at the same time, the sub-projects that are not relied upon are not called.

[0129] For example, the project name is Editor (hereinafter referred to as Editor), which contains two sub-projects: tools (hereinafter referred to as tools) and main (hereinafter referred to as main). Tools generates a static library, whose function is to provide some practical tools for main, specifically source code files, etc., to assist sub-project main in generating executable files. The configuration file of the Editor project is organized as follows:

[0130]

[0131]

[0132] As shown in the above example, it can be seen that the configuration file of the Editor project includes the names of the sub-projects main and tools, which are the same as the names of the sub-project folders, and based on the dependencies, the corresponding sub-projects are added to the sub-project folders of the corresponding types.

[0133] S102: compiling source code files corresponding to the plurality of sub-projects respectively according to the configuration file to obtain target files corresponding to the plurality of sub-projects respectively.

[0134] The target file is a file obtained by compiling source code files corresponding to multiple sub-projects based on the configuration file.

[0135] Taking the generation of a C / C++ software project as an example, the extension of the generated target file is, for example, xxx.o, where xxx represents identification information such as the file name, number, characters, etc.; .o represents the suffix of the target file, also known as the object file. Specifically, the .o file can be linked or packaged into a project file. For example, multiple .o files can be linked into an executable file.

[0136] In the embodiment of the present disclosure, according to the configuration file, source code files corresponding to the plurality of sub-projects are compiled to obtain target files corresponding to the plurality of sub-projects. The detailed process is as follows:

[0137] A: When the source code files of the subproject include: a first source code file that is relied upon by other subprojects, and / or a second source code file that is not relied upon by other subprojects, the source code files corresponding to the plurality of subprojects are compiled according to the configuration file to obtain target files corresponding to the plurality of subprojects, including:

[0138] For each of the plurality of subprojects, in response to determining that each of the subprojects corresponds to a dependent subproject based on the dependency information, obtaining a target first source code file that each of the subprojects depends on from a first source code file corresponding to the dependent subproject;

[0139] The target first source code file that each sub-project depends on and the source code file corresponding to each sub-project are compiled to obtain the target file corresponding to each sub-project.

[0140] Specifically, based on the dependencies between the sub-projects marked in the configuration file, the dependent sub-projects called by the target are determined. Taking the above example, based on the information marked in the configuration file, it can be determined that main needs to call some source code files in the tools sub-project and obtain these target source code files.

[0141] B: The dependency information includes: subproject identifiers of dependent subprojects corresponding to the plurality of subprojects, and identifiers of dependent source code files. Correspondingly, obtaining the target first source code file that each subproject depends on includes: generating an access path to the target first source code file based on the subproject identifiers of dependent subprojects corresponding to each subproject, the identifiers of dependent source code files, and the organization forms of source code files of the plurality of subprojects; and obtaining the target first source code file that each subproject depends on based on the access path.

[0142] The organization forms of the source code files of the multiple sub-projects include:

[0143] The source code files corresponding to different sub-projects are stored in different folders, and for each sub-project, in response to each sub-project including a first source code file, the first source code file is stored in a first type of sub-folder in the folder of the corresponding sub-project; in response to each sub-project including a second source code file, the second source code file is stored in a second type of sub-folder in the folder of the corresponding sub-project.

[0144] C: The first type and the second type are dependent files and non-dependent files, such as inc files and src files. Taking the above example, for a subproject that outputs a static library, the header files that need to be referenced externally are placed in the first type of inc folder, and the source code files within the project and the header files that are not referenced externally are placed in the second type of src folder.

[0145] In the above example of the embodiment of the present disclosure, based on the dependency relationship of the main sub-project, the tools sub-project on which it depends is determined, and the source code identifier tools stored in the inc file of the dependent folder that needs to be depended on from the tools sub-project is determined, and based on the above information, the access path of |---tools.h is determined, and through this path, the target first source code file in the tools sub-project is obtained.

[0146] After the subproject obtains the dependent first source code file, the target first source code file that each subproject depends on and the source code file corresponding to each subproject can be compiled to obtain the target file corresponding to each subproject. Specifically, for each subproject among the multiple subprojects, based on the second type information of the compilation result corresponding to each subproject, the source code file of each subproject is compiled to obtain the target file matching the type information of the compilation result corresponding to each subproject.

[0147] During the compilation process, when multiple sub-projects correspond to the second type of information, the second type of information of the compilation results corresponding to the multiple sub-projects can also be read from the configuration file. Specifically, the second type of information is the file type corresponding to each sub-project after compilation. Taking the above example as an example, the main sub-project compiles to the target file corresponding to the executable file, and the tools sub-project compiles to the target file corresponding to the library file. After obtaining the dependent target first source code file, the target file corresponding to each sub-project can be compiled based on the file type obtained by the target and combined with its own source code file.

[0148] Exemplarily, when building a subproject, the compile parameters, such as -c, -fPIC, -O2, etc., are determined according to the output type of the subproject and other specified compilation-related parameters. Here, there is a certain correspondence between the output type and the parameter. If the output type is a dynamic library, there will be -fPIC. If the output type is a header file, no compilation parameters are required. Other compilation parameters can be specified in the configuration file, etc. For example, compile tools.cpp, tool_1.cpp, tool_2.cpp to obtain the corresponding target files: tools.o, tool_1.o, tool_2.o.

[0149] D: According to the configuration file, source code files corresponding to the plurality of sub-projects are compiled to obtain target files corresponding to the plurality of sub-projects, including:

[0150] Determining a construction order of the plurality of sub-projects based on dependency information between the plurality of sub-projects included in the configuration file;

[0151] According to the construction order of the multiple sub-projects, the source code files corresponding to the multiple sub-projects are compiled in sequence to obtain the target files corresponding to the multiple sub-projects.

[0152] The step of determining the construction order of the multiple sub-projects includes: establishing a topological structure corresponding to the multiple sub-projects based on the dependency information between the multiple sub-projects included in the configuration file, and determining the construction order of the multiple sub-projects based on the topological structure.

[0153] For example, the dependencies between all sub-projects in the configuration file can be analyzed, such as the dependency relationship of a depending on b, and b depending on c, and topological sorting can be performed to obtain the topological sorting result abc, and the result can be used as the build order for the three sub-projects a, b, and c, and each sub-project can be built in turn.

[0154] S103: Preset processing is performed on the target files of the plurality of sub-projects to obtain the project file of the target project.

[0155] In a specific implementation, after the target file is compiled, the target file of the sub-project may be processed to obtain a project file.

[0156] In the embodiment of the present disclosure, the preset processing is associated with the first type of information of the compilation result of the target project. The preset processing may include linking, packaging, copying, etc. Specifically, according to the preset processing mode indicated by the first type of information of the compilation result corresponding to the target project included in the configuration file, at least one preset processing of linking, packaging, copying, etc. is performed on the target files of the plurality of sub-projects to obtain the project file of the target project.

[0157] Specifically, the first type of information includes: a static database, and the preset processing method indicated by the first type of information includes: packaging the target file into a static database;

[0158] The first type of information includes: an executable file, and the preset processing method indicated by the first type of information includes: linking the target file into an executable file;

[0159] The first type of information includes: a header file, and the preset processing method indicated by the first type of information includes: copying the target file to a target output folder.

[0160] Exemplarily, according to the first type information of the compilation result corresponding to the target project, that is, the output type of the target project, the target file is packaged into a static library, a dynamic library, or linked into an executable file, or the header file that needs to be referenced is copied. That is, when the output type is a dynamic library or a static library, the target file needs to be packaged to obtain the corresponding static library or dynamic library, for example, the target file is packaged into a static library file libtools.a; when the output type is an executable file, the target file needs to be linked to obtain an executable file xxx.exe; when the output type is a header file, the target file needs to be copied to the target output folder, for example, the folder tools / inc and the static library libtools.a are copied to the output folder specified by the user, etc.

[0161] In another possible implementation of the present disclosure, the further method further includes: in response to a change in a source code file in the sub-project, updating configuration information corresponding to the sub-project in the configuration file;

[0162] The changes include one or more of the following: addition, deletion, and modification.

[0163] In this embodiment, when it is necessary to add or adjust a sub-project, the corresponding configuration information can be added to the configuration file; when it is necessary to delete or adjust a sub-project, the corresponding configuration information can be deleted from the configuration file, and the configuration information corresponding to other sub-projects with which it has a dependency relationship can be modified. For example, the description of the newly added sub-project can be added or the description of the target sub-project can be changed; in this way, there is no need to modify the configuration files corresponding to multiple sub-projects respectively as in the related art, but only the content of the configuration file of the target project can be adjusted, which reduces the developer's processing process for the configuration files of the sub-projects.

[0164] The disclosed embodiment establishes a configuration file for the target project instead of for each source code file, and processes the target project using the configuration file corresponding to the target project, thereby reducing the workload required for writing the configuration file, and once a source code file or sub-project is to be added or deleted in the project, it is only necessary to modify the configuration file corresponding to the target project, thereby reducing the time required for modifying the configuration file, improving the efficiency of project construction, and reducing costs.

[0165] Those skilled in the art will appreciate that, in the above method of specific implementation, the order in which the steps are written does not imply a strict execution order and does not constitute any limitation on the implementation process. The specific execution order of the steps should be determined by their functions and possible internal logic.

[0166] Based on the same inventive concept, a compilation device corresponding to the compilation method is also provided in the embodiment of the present disclosure. Since the principle of solving the problem by the device in the embodiment of the present disclosure is similar to the above-mentioned compilation method in the embodiment of the present disclosure, the implementation of the device can refer to the implementation of the method, and the repeated parts will not be repeated.

[0167] Reference Figure 2 FIG. 2 is a schematic diagram of the architecture of a compiling device provided by an embodiment of the present disclosure, wherein the device comprises: a building module 210, a compiling module 220, and a processing module 230; wherein:

[0168] Establishing module 210, used to establish a configuration file when building a target project; wherein the configuration file includes at least one of the following: sub-project identifiers corresponding to multiple sub-projects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to multiple sub-projects, dependency information between multiple sub-projects, and compilation parameters corresponding to multiple sub-projects;

[0169] A compiling module 220, configured to compile source code files corresponding to the plurality of sub-projects respectively according to the configuration file to obtain target files corresponding to the plurality of sub-projects respectively;

[0170] The processing module 230 is used to perform preset processing on the target files of the plurality of sub-projects to obtain the project file of the target project.

[0171] In an optional implementation, the configuration file includes: dependency information between the plurality of sub-projects, and the source code files of the sub-projects include: a first source code file that is dependent on other sub-projects, and / or a second source code file that is not dependent on other sub-projects;

[0172] The compiling module 220 includes:

[0173] An acquiring unit 221 is configured to acquire, for each of the plurality of subprojects, a target first source code file that each subproject depends on from a first source code file corresponding to the dependent subproject in response to determining that each subproject corresponds to a dependent subproject based on the dependency relationship information;

[0174] The first compiling unit 222 is used to compile the target first source code file that each sub-project depends on and the source code file corresponding to each sub-project to obtain the target file corresponding to each sub-project.

[0175] In an optional implementation manner, the dependency relationship information includes: sub-project identifiers of dependent sub-projects corresponding to the plurality of sub-projects, and dependent source code file identifiers;

[0176] The acquisition unit 221 is specifically used for:

[0177] Generate an access path to the target first source code file based on the subproject identifier of the dependent subproject corresponding to each subproject, the dependent source code file identifier, and the organization form of the source code files of the plurality of subprojects;

[0178] Based on the access path, a target first source code file that each sub-project depends on is obtained.

[0179] In an optional implementation manner, the organization form of the source code files of the plurality of sub-projects includes:

[0180] The source code files corresponding to different sub-projects are stored in different folders, and for each sub-project, in response to each sub-project including a first source code file, the first source code file is stored in a first type of sub-folder in the folder of the corresponding sub-project; in response to each sub-project including a second source code file, the second source code file is stored in a second type of sub-folder in the folder of the corresponding sub-project.

[0181] In an optional implementation manner, the configuration file includes: second type information of compilation results corresponding to the plurality of sub-projects respectively, and the compilation module 220 is specifically used for:

[0182] For each subproject among the multiple subprojects, based on the second type information of the compilation result corresponding to each subproject, the source code file of each subproject is compiled to obtain a target file matching the type information of the compilation result corresponding to each subproject.

[0183] In an optional implementation, the configuration file includes: dependency information between the plurality of sub-projects, and the compiling module 220 further includes:

[0184] A determining unit 223, configured to determine a construction order of the plurality of sub-projects based on dependency information between the plurality of sub-projects included in the configuration file;

[0185] The second compiling unit 224 is used to compile the source code files respectively corresponding to the multiple sub-projects in sequence according to the construction order of the multiple sub-projects to obtain the target files respectively corresponding to the multiple sub-projects.

[0186] In an optional implementation manner, the determining unit 221 is specifically configured to:

[0187] Based on the dependency information between the multiple sub-items included in the configuration file, establishing a topological structure corresponding to the multiple sub-items;

[0188] Based on the topological structure, a construction order of the plurality of sub-projects is determined.

[0189] In an optional implementation, the configuration file includes: first type information of the compilation result corresponding to the target project, and the processing module 230 is specifically used to:

[0190] According to the preset processing mode indicated by the first type information of the target project, the target files of the plurality of sub-projects are preset processed to obtain the project file of the target project; wherein the preset processing is associated with the first type information of the compilation result of the target project.

[0191] In an optional implementation, the type information includes any one of the following:

[0192] Dynamic databases, static databases, executable files, and header files;

[0193] The type information includes: first type information and / or second type information.

[0194] In an optional implementation manner, the first type of information includes: a dynamic database, and the preset processing method indicated by the first type of information includes: packaging the target file into a dynamic database;

[0195] The first type of information includes: a static database, and the preset processing method indicated by the first type of information includes: packaging the target file into a static database;

[0196] The first type of information includes: an executable file, and the preset processing method indicated by the first type of information includes: linking the target file into an executable file;

[0197] The first type of information includes: a header file, and the preset processing method indicated by the first type of information includes: copying the target file to a target output folder.

[0198] The disclosed embodiment establishes a configuration file for the target project instead of for each source code file, and processes the target project using the configuration file corresponding to the target project, thereby reducing the workload required for writing the configuration file, and once a source code file or sub-project is to be added or deleted in the project, it is only necessary to modify the configuration file corresponding to the target project, thereby reducing the time required for modifying the configuration file, improving the efficiency of project construction, and reducing costs.

[0199] For descriptions of the processing flow of each module in the device and the interaction flow between each module, reference may be made to the relevant descriptions in the above method embodiment, which will not be described in detail here.

[0200] Based on the same technical concept, the embodiment of the present disclosure also provides a computer device. Figure 5 As shown, it is a schematic diagram of the structure of a computer device provided by an embodiment of the present disclosure, including a processor 501, a memory 502, and a bus 503. Among them, the memory 502 is used to store execution instructions, including a memory 5021 and an external memory 5022; the memory 5021 here is also called an internal memory, which is used to temporarily store the operation data in the processor 501, and the data exchanged with the external memory 5022 such as a hard disk. The processor 501 exchanges data with the external memory 5022 through the memory 5021. When the computer device is running, the processor 501 communicates with the memory 502 through the bus 503, so that the processor 501 executes the following instructions:

[0201] Establishing a configuration file when building a target project; wherein the configuration file includes at least one of the following: subproject identifiers corresponding to the plurality of subprojects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to the plurality of subprojects, dependency information between the plurality of subprojects, and compilation parameters corresponding to the plurality of subprojects;

[0202] According to the configuration file, source code files corresponding to the plurality of sub-projects are compiled to obtain target files corresponding to the plurality of sub-projects;

[0203] The target files of the plurality of sub-projects are preset to obtain the project file of the target project.

[0204] The present disclosure also provides a computer-readable storage medium on which a computer program is stored, and when the computer program is executed by a processor, the steps of the compiling method described in the above method embodiment are executed. The storage medium may be a volatile or non-volatile computer-readable storage medium.

[0205] The computer program product of the compilation method provided in the embodiments of the present disclosure includes a computer-readable storage medium storing program code, and the instructions included in the program code can be used to execute the steps of the compilation method described in the above method embodiments. For details, please refer to the above method embodiments, which will not be repeated here.

[0206] The present disclosure also provides a computer program, which implements any one of the methods of the aforementioned embodiments when executed by a processor. The computer program product can be implemented in hardware, software, or a combination thereof. In an optional embodiment, the computer program product is embodied as a computer storage medium, and in another optional embodiment, the computer program product is embodied as a software product, such as a software development kit (SDK), etc.

[0207] Those skilled in the art can clearly understand that, for the convenience and simplicity of description, the specific working process of the system and device described above can refer to the corresponding process in the aforementioned method embodiment, and will not be repeated here. In the several embodiments provided in the present disclosure, it should be understood that the disclosed system, device and method can be implemented in other ways. The device embodiments described above are merely schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some communication interfaces, and the indirect coupling or communication connection of the device or unit can be electrical, mechanical or other forms.

[0208] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0209] In addition, each functional unit in each embodiment of the present disclosure may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0210] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a non-volatile computer-readable storage medium that is executable by a processor. Based on this understanding, the technical solution of the present disclosure, or the part that contributes to the prior art or the part of the technical solution, can be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present disclosure. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0211] Finally, it should be noted that the above-described embodiments are only specific implementation methods of the present disclosure, which are used to illustrate the technical solutions of the present disclosure, rather than to limit them. The protection scope of the present disclosure is not limited thereto. Although the present disclosure is described in detail with reference to the above-described embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above-described embodiments within the technical scope disclosed in the present disclosure, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present disclosure, and should be included in the protection scope of the present disclosure. Therefore, the protection scope of the present disclosure should be based on the protection scope of the claims.

Claims

1. A compiling method, characterized in that: include: Establishing a configuration file when building a target project; wherein the configuration file includes at least one of the following: subproject identifiers corresponding to the plurality of subprojects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to the plurality of subprojects, dependency information between the plurality of subprojects, and compilation parameters corresponding to the plurality of subprojects; According to the configuration file, source code files corresponding to the plurality of sub-projects are compiled to obtain target files corresponding to the plurality of sub-projects; Preset processing is performed on the target files of the plurality of sub-projects to obtain the project file of the target project; The configuration file includes: dependency information between the plurality of sub-projects, and the source code files of the sub-projects include: a first source code file that is dependent on other sub-projects, and / or a second source code file that is not dependent on other sub-projects; The source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects, including: For each of the plurality of subprojects, in response to determining that each of the subprojects corresponds to a dependent subproject based on the dependency information, obtaining a target first source code file that each of the subprojects depends on from a first source code file corresponding to the dependent subproject; The target first source code file that each sub-project depends on and the source code file corresponding to each sub-project are compiled to obtain the target file corresponding to each sub-project.

2. The method according to claim 1, characterized in that The dependency relationship information includes: sub-project identifiers of dependent sub-projects corresponding to the plurality of sub-projects, and identifiers of dependent source code files; The obtaining of the target first source code file that each sub-project depends on includes: Generate an access path to the target first source code file based on the subproject identifier of the dependent subproject corresponding to each subproject, the dependent source code file identifier, and the organization form of the source code files of the plurality of subprojects; Based on the access path, a target first source code file that each sub-project depends on is obtained.

3. The method according to claim 2, characterized in that The organization forms of the source code files of the multiple sub-projects include: The source code files corresponding to different sub-projects are stored in different folders, and for each sub-project, in response to each sub-project including a first source code file, the first source code file is stored in a first type of sub-folder in the folder of the corresponding sub-project; in response to each sub-project including a second source code file, the second source code file is stored in a second type of sub-folder in the folder of the corresponding sub-project.

4. The method according to any one of claims 1 to 3, characterized in that: The configuration file includes: second type information of compilation results corresponding to the plurality of sub-projects respectively, and the source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects respectively, including: For each subproject among the multiple subprojects, based on the second type information of the compilation result corresponding to each subproject, the source code file of each subproject is compiled to obtain a target file matching the type information of the compilation result corresponding to each subproject.

5. The method according to any one of claims 1 to 3, characterized in that: The configuration file includes: dependency information between the plurality of sub-projects, and the source code files corresponding to the plurality of sub-projects are compiled according to the configuration file to obtain target files corresponding to the plurality of sub-projects, including: Determining a construction order of the plurality of sub-projects based on dependency information between the plurality of sub-projects included in the configuration file; According to the construction order of the multiple sub-projects, the source code files corresponding to the multiple sub-projects are compiled in sequence to obtain the target files corresponding to the multiple sub-projects.

6. The method according to claim 5, characterized in that The determining the construction order of the plurality of sub-projects based on the dependency information between the plurality of sub-projects included in the configuration file comprises: Based on the dependency information between the multiple sub-items included in the configuration file, establishing a topological structure corresponding to the multiple sub-items; Based on the topological structure, a construction order of the plurality of sub-projects is determined.

7. The method according to any one of claims 1 to 3, characterized in that: The configuration file includes: first type information of the compilation result corresponding to the target project, and the target files of the plurality of sub-projects are processed by preset processing to obtain the project file of the target project, including: According to the preset processing mode indicated by the first type information of the target project, the target files of the plurality of sub-projects are preset processed to obtain the project file of the target project; wherein the preset processing is associated with the first type information of the compilation result of the target project.

8. The method according to any one of claims 1 to 3, characterized in that: Type information includes any of the following: Dynamic databases, static databases, executable files, and header files; The type information includes: first type information and / or second type information.

9. The method according to claim 1, characterized in that: The first type of information includes: a dynamic database, and the preset processing method indicated by the first type of information includes: packaging the target file into a dynamic database; The first type of information includes: a static database, and the preset processing method indicated by the first type of information includes: packaging the target file into a static database; The first type of information includes: an executable file, and the preset processing method indicated by the first type of information includes: linking the target file into an executable file; The first type of information includes: a header file, and the preset processing method indicated by the first type of information includes: copying the target file to a target output folder.

10. A compiling device, characterized in that: include: A building module, used to build a configuration file when building a target project; wherein the configuration file includes at least one of the following: sub-project identifiers corresponding to multiple sub-projects of the target project, first type information of compilation results corresponding to the target project, second type information of compilation results corresponding to multiple sub-projects, dependency information between multiple sub-projects, and compilation parameters corresponding to multiple sub-projects; A compiling module, used to compile source code files corresponding to the plurality of sub-projects respectively according to the configuration file, to obtain target files corresponding to the plurality of sub-projects respectively; A processing module, used for performing preset processing on the target files of the plurality of sub-projects to obtain the project file of the target project; The configuration file includes: dependency information between the plurality of sub-projects, and the source code files of the sub-projects include: a first source code file that is dependent on other sub-projects, and / or a second source code file that is not dependent on other sub-projects; The compilation module is specifically used for: For each of the plurality of subprojects, in response to determining that each of the subprojects corresponds to a dependent subproject based on the dependency information, obtaining a target first source code file that each of the subprojects depends on from a first source code file corresponding to the dependent subproject; The target first source code file that each sub-project depends on and the source code file corresponding to each sub-project are compiled to obtain the target file corresponding to each sub-project.

11. A computer device, characterized in that: include: A processor, a memory and a bus, wherein the memory stores machine-readable instructions executable by the processor, and when the computer device is running, the processor and the memory communicate via the bus, and when the machine-readable instructions are executed by the processor, the steps of the compilation method according to any one of claims 1 to 9 are performed.

12. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of the compilation method according to any one of claims 1 to 9 are executed.

Images