CN109460236B - Program version construction and checking method and system - Google Patents
Program version construction and checking method and system Download PDFInfo
- Publication number
- CN109460236B CN109460236B CN201811221216.5A CN201811221216A CN109460236B CN 109460236 B CN109460236 B CN 109460236B CN 201811221216 A CN201811221216 A CN 201811221216A CN 109460236 B CN109460236 B CN 109460236B
- Authority
- CN
- China
- Prior art keywords
- node
- program
- executable code
- version
- hash value
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000010276 construction Methods 0.000 title claims abstract description 45
- 238000000034 method Methods 0.000 title claims abstract description 32
- 238000004590 computer program Methods 0.000 claims description 16
- 238000007689 inspection Methods 0.000 claims description 6
- 238000004364 calculation method Methods 0.000 claims description 5
- 238000004458 analytical method Methods 0.000 claims description 3
- 238000000605 extraction Methods 0.000 claims description 2
- 238000010586 diagram Methods 0.000 description 11
- 230000006870 function Effects 0.000 description 6
- 230000008569 process Effects 0.000 description 2
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method and a system for constructing and checking a program version. The method comprises the following steps: extracting a source program of a program to be processed from the version library according to the version mark; reading an executable code list from the configuration file, analyzing the calling dependency relationship of each executable code in the executable code list in a source program of the program to be processed, and forming a dependency relationship tree; traversing each node on the dependency tree, and calculating the hash value of each node; compiling a source program of a program to be processed into an executable code; writing the hash value of the top node of the dependency tree into the compiled executable code; and checking the version construction by using the hash value of the top node of the dependency relationship tree. The invention can realize automatic construction and check of the program version.
Description
Technical Field
The invention relates to the technical field of program development, in particular to a method and a system for constructing and checking a program version.
Background
In the process of program development, the construction of the version is always relatively complicated and is easy to make mistakes. When the version is built, the correct source program to be built and all the called source programs need to be built correctly, and then the correct executable code can be built finally. When program versions are built in small-sized machine environments such as AIX (advanced Interactive Xeco), currently, no automatic version building tool is available, whether any given executable code which is built is successfully built cannot be inferred, and in the prior art, workers are assisted to judge according to information such as the size of the built executable code and the building time, so that efficiency is low, and reliability is poor.
Therefore, it is necessary to provide a program version constructing and checking method and system.
Disclosure of Invention
The embodiment of the invention provides a program version constructing and checking method, which is used for realizing automatic construction and checking of a program version and comprises the following steps:
extracting a source program of a program to be processed from the version library according to the version mark;
reading an executable code list from the configuration file, analyzing the calling dependency relationship of each executable code in the executable code list in a source program of the program to be processed, and forming a dependency relationship tree;
traversing each node on the dependency tree, and calculating the hash value of each node;
compiling a source program of a program to be processed into an executable code;
writing the hash value of the top node of the dependency tree into the compiled executable code;
and checking the version construction by using the hash value of the top node of the dependency relationship tree.
Optionally, after compiling the source program of the program to be processed into an executable code, storing the compiled executable code into a version library;
and checking the version construction result, re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes the version construction check.
Optionally, the method further includes:
and creating a check list according to the check result, and constructing the check result by using the check list display version.
Optionally, traversing each node on the dependency tree, and calculating a hash value of each node, includes:
judging whether the node to be processed is the lowest node of the dependency tree or not;
if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node;
and if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node.
Optionally, compiling the source program of the program to be processed into an executable code, including:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
The embodiment of the invention also provides a program version constructing and checking system, which is used for realizing the automatic construction and checking of the program version, and the system comprises:
the extraction module is used for extracting a source program of the program to be processed from the version library according to the version mark;
the analysis module is used for reading an executable code list from the configuration file, analyzing the calling dependency relationship of each executable code in the executable code list in the source program of the program to be processed and forming a dependency relationship tree;
the node calculation module is used for traversing each node on the dependency tree and calculating the hash value of each node;
the executable code building module is used for compiling the source program of the program to be processed into an executable code;
the writing module is used for writing the hash value of the top node of the dependency tree into the compiled executable code;
and the checking module is used for checking the version construction by utilizing the hash value of the top node of the dependency tree.
Optionally, the checking module is further configured to:
storing the compiled executable code into a version library;
and re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes version construction check.
Optionally, the system further comprises:
and the display module is used for creating a check list according to the check result and constructing the check result by utilizing the check list display version.
Optionally, the node calculation module is further configured to:
judging whether the node to be processed is the lowest node of the dependency tree or not;
if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node;
and if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node.
Optionally, the executable code constructing module is further configured to:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
The embodiment of the present invention further provides a computer device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor implements the method when executing the computer program.
An embodiment of the present invention further provides a computer-readable storage medium, in which a computer program for executing the above method is stored.
In the embodiment of the invention, the calling dependency relationship of each executable code in the executable code list in the source program of the program to be processed is analyzed by reading the executable code list from the configuration file to form a dependency relationship tree; traversing each node on the dependency tree, and calculating the hash value of each node; compiling a source program of a program to be processed into an executable code; and the hash value of the top node of the dependency relationship tree is attached and written into the compiled executable code, and meanwhile, the version construction is checked by utilizing the hash value of the top node of the dependency relationship tree, so that the automatic construction and checking of the program version are realized.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts. In the drawings:
FIG. 1 is a flowchart illustrating a method for building and checking program versions according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of a program version build and check system in an embodiment of the present invention;
FIG. 3 is a diagram of an exemplary program version build and check system according to an embodiment of the present invention;
fig. 4 is a diagram illustrating an exemplary method for constructing and checking a program version according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the embodiments of the present invention are further described in detail below with reference to the accompanying drawings. The exemplary embodiments and descriptions of the present invention are provided to explain the present invention, but not to limit the present invention.
The following explains the terms to which the present invention relates:
"hash value": data of an arbitrary length is converted into data of a fixed length by a hash operation.
"hash operation": and calculating a hash value through a hash function.
An embodiment of the present invention provides a method for constructing and checking a program version, as shown in fig. 1, where the method includes:
and step 101, extracting a source program of a program to be processed from the version library according to the version mark.
And 103, traversing each node on the dependency relationship tree, and calculating the hash value of each node.
And step 104, compiling the source program of the program to be processed into executable code.
And 105, writing the hash value of the top node of the dependency tree into the compiled executable code.
And 106, checking the version construction by using the hash value of the top-layer node of the dependency relationship tree.
As can be known from the flow shown in fig. 1, in the embodiment of the present invention, an executable code list is read from a configuration file, and a call dependency relationship of each executable code in the executable code list in a source program of a to-be-processed program is analyzed to form a dependency relationship tree; traversing each node on the dependency tree, and calculating the hash value of each node; compiling a source program of a program to be processed into an executable code; and the hash value of the top node of the dependency relationship tree is attached and written into the compiled executable code, and meanwhile, the version construction is checked by utilizing the hash value of the top node of the dependency relationship tree, so that the automatic construction and checking of the program version are realized.
Wherein, traversing each node on the dependency tree refers to accessing each node from bottom to top.
In order to successfully check the correctness of the compiled executable code, the hash value of the top node of the dependency tree is used for checking the program version construction, and the method comprises the following steps:
storing the compiled executable code into a version library;
and re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes version construction check.
In order to clearly show the checking result of the version build to the user, the program version build and checking method further includes:
and creating a check list according to the check result, and constructing the check result by using the check list display version.
In the embodiment of the present invention, traversing each node on the dependency tree, and calculating the hash value of each node includes:
judging whether the node to be processed is the lowest node of the dependency tree or not;
if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node;
and if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node.
Specifically, the hash values of the nodes in the dependency tree are calculated from bottom to top, when the node to be calculated is not the bottom node, the source program of the corresponding program is always combined with the hash values of all nodes in the next layer, hash operation is performed to calculate the hash value of the node, and the steps are repeated until the hash value of the top node of the dependency tree is calculated.
In order to smoothly construct program versions for different formats, a source program of a program to be processed is compiled into executable codes, and the method comprises the following steps:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
Wherein GBK is called as "Chinese Internal Code extension Standard" (GBK is the first letter of Chinese Pinyin of "national Standard" and "extension", English name: Chinese Internal Code Specification). UTF-8(Unicode Transformation Format) is a variable length character code for Unicode, also known as Unicode.
Further, a specific example of an embodiment of the present invention can be seen in fig. 4.
Based on the same inventive concept, the embodiment of the present invention further provides a program version constructing and checking system, as described in the following embodiments. Because the principle of solving the problem of the program version construction and inspection system is similar to that of the program version construction and inspection method, the implementation of the program version construction and inspection system can refer to the implementation of the program version construction and inspection method, and repeated parts are not described again. As used hereinafter, the term "unit" or "module" may be a combination of software and/or hardware that implements a predetermined function. While the system described in the embodiments below is preferably implemented in software, implementations in hardware, or a combination of software and hardware are also possible and contemplated.
An embodiment of the present invention provides a program version building and checking system, as shown in fig. 2, the system includes:
an extracting module 201, configured to extract a source program of a program to be processed from the version library according to the version flag;
the analysis module 202 is configured to read an executable code list from the configuration file, analyze a call dependency relationship of each executable code in the executable code list in a source program of the to-be-processed program, and form a dependency relationship tree;
the node calculation module 203 is configured to traverse each node in the dependency tree and calculate a hash value of each node;
an executable code constructing module 204, configured to compile a source program of a program to be processed into an executable code;
a writing module 205, configured to write the hash value of the top node of the dependency tree into the compiled executable code.
And the checking module 206 is configured to check the version construction by using the hash value of the top node of the dependency tree.
In an embodiment of the present invention, the checking module 206 is further configured to:
storing the compiled executable code into a version library;
and re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes version construction check.
As shown in fig. 3, the system further comprises:
and the display module 207 is used for creating a check list according to the check result and constructing the check result by using the check list display version.
In one embodiment, the node calculating module 203 is further configured to:
judging whether the node to be processed is the lowest node of the dependency tree or not;
if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node;
and if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node.
In one embodiment, the executable code building module 204 is further configured to:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
The embodiment of the present invention further provides a computer device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor implements the above method when executing the computer program.
An embodiment of the present invention further provides a computer-readable storage medium, in which a computer program for executing the above method is stored.
In the embodiment of the invention, an executable code list is read from a configuration file, and the calling dependency relationship of each executable code in the executable code list in a source program of a program to be processed is analyzed to form a dependency relationship tree; traversing each node on the dependency tree, and calculating the hash value of each node; compiling a source program of a program to be processed into an executable code; and the hash value of the top node of the dependency tree is attached and written into the compiled executable code, so that the automatic construction of the program version is realized.
In the embodiment, by checking any given executable code, the correctness of the version construction can be ensured, and the efficiency of the version construction and the checking is improved. And a check list is formed after checking, so that a user can conveniently check the check result.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create a system for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including an instruction system which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The above-mentioned embodiments are intended to illustrate the objects, technical solutions and advantages of the present invention in further detail, and it should be understood that the above-mentioned embodiments are only exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (8)
1. A program version building and checking method, comprising:
extracting a source program of a program to be processed from the version library according to the version mark;
reading an executable code list from the configuration file, analyzing the calling dependency relationship of each executable code in the executable code list in a source program of the program to be processed, and forming a dependency relationship tree;
traversing each node on the dependency tree, and calculating the hash value of each node;
compiling a source program of a program to be processed into an executable code;
writing the hash value of the top node of the dependency tree into the compiled executable code;
checking the version construction by using the hash value of the top node of the dependency relationship tree;
traversing each node on the dependency tree, and calculating the hash value of each node, wherein the steps comprise: judging whether the node to be processed is the lowest node of the dependency tree or not; if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node; if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node;
the method for checking the program version construction by utilizing the hash value of the top node of the dependency tree comprises the following steps: storing the compiled executable code into a version library; and re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes version construction check.
2. The method of claim 1, wherein the method further comprises:
and creating a check list according to the check result, and constructing the check result by using the check list display version.
3. The method of claim 1, wherein compiling a source program of a program to be processed into executable code comprises:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
4. A program version building and inspection system, comprising:
the extraction module is used for extracting a source program of the program to be processed from the version library according to the version mark;
the analysis module is used for reading an executable code list from the configuration file, analyzing the calling dependency relationship of each executable code in the executable code list in the source program of the program to be processed and forming a dependency relationship tree;
the node calculation module is used for traversing each node on the dependency tree and calculating the hash value of each node;
the executable code building module is used for compiling the source program of the program to be processed into an executable code;
the writing module is used for writing the hash value of the top node of the dependency tree into the compiled executable code;
the checking module is used for checking the version construction by utilizing the hash value of the top node of the dependency tree;
the node calculation module is further to: judging whether the node to be processed is the lowest node of the dependency tree or not; if the node is the bottommost node, performing hash operation by using a source program of a program corresponding to the node, and calculating a hash value of the bottommost node; if the node is not the node at the bottommost layer, combining the source program of the program corresponding to the node with the hash values of all nodes at the next layer, and performing hash operation to calculate the hash value of the node;
the inspection module is further to: storing the compiled executable code into a version library; and re-extracting the source program of the program to be processed from the version library, calculating the hash value of the top node of the dependency tree corresponding to the re-extracted source program, and if the hash value of the top node of the dependency tree is consistent with the hash value corresponding to any given executable code in the version library, the executable code passes version construction check.
5. The system of claim 4, further comprising:
and the display module is used for creating a check list according to the check result and constructing the check result by utilizing the check list display version.
6. The system of claim 4, wherein the executable code building module is further to:
judging the coding format of a program source program;
if the GBK format is adopted, executing the construction file in the GBK format to construct;
and if the UTF-8 format is adopted, executing the construction file of the UTF-8 format to construct.
7. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, wherein the processor implements the method of any one of claims 1 to 3 when executing the computer program.
8. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program for executing the method of any one of claims 1 to 3.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811221216.5A CN109460236B (en) | 2018-10-19 | 2018-10-19 | Program version construction and checking method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811221216.5A CN109460236B (en) | 2018-10-19 | 2018-10-19 | Program version construction and checking method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109460236A CN109460236A (en) | 2019-03-12 |
| CN109460236B true CN109460236B (en) | 2021-12-07 |
Family
ID=65607911
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811221216.5A Active CN109460236B (en) | 2018-10-19 | 2018-10-19 | Program version construction and checking method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109460236B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111367563B (en) * | 2020-03-06 | 2024-02-23 | 中国银行股份有限公司 | Host version merging method and device |
| CN113971031A (en) * | 2021-10-28 | 2022-01-25 | 中国银行股份有限公司 | Software package dependency relationship checking method and device |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108363580A (en) * | 2018-03-12 | 2018-08-03 | 平安普惠企业管理有限公司 | Application program installation method, device, computer equipment and storage medium |
| CN108595186A (en) * | 2018-03-27 | 2018-09-28 | 天津麒麟信息技术有限公司 | Multiversion software management method based on total function on a kind of platform of soaring |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| SG11201706846TA (en) * | 2015-02-26 | 2017-09-28 | Alpha Mice Ltd | A method to identify known compilers functions, libraries and objects inside files and data items containing an executable code |
-
2018
- 2018-10-19 CN CN201811221216.5A patent/CN109460236B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108363580A (en) * | 2018-03-12 | 2018-08-03 | 平安普惠企业管理有限公司 | Application program installation method, device, computer equipment and storage medium |
| CN108595186A (en) * | 2018-03-27 | 2018-09-28 | 天津麒麟信息技术有限公司 | Multiversion software management method based on total function on a kind of platform of soaring |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109460236A (en) | 2019-03-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9128723B2 (en) | Method and apparatus for dynamic document object model (DOM) aware code editing | |
| CN104679495B (en) | software identification method and device | |
| JP6440895B2 (en) | Software analysis apparatus and software analysis method | |
| CN106933835A (en) | The data lead-in method and system of a kind of compatibility parsing Excel file | |
| US9465591B2 (en) | Syntax language generator for compiler validation | |
| CN108469955B (en) | Annotation-based Android injection framework implementation method | |
| CN106778278A (en) | A kind of malice document detection method and device | |
| CN109460236B (en) | Program version construction and checking method and system | |
| CN108846069B (en) | Document execution method and device based on markup language | |
| CN105843661B (en) | A kind of code method for relocating and its system towards host system | |
| CN107797805B (en) | Code packaging method and device and computer readable storage medium | |
| CN111158665B (en) | Code generation method and device, electronic equipment and storage medium | |
| CN112035367B (en) | Method and system for checking workflow correctness of big data platform | |
| CN110737588A (en) | automatic point burying method, device, medium and electronic equipment | |
| CN105867886B (en) | Method and device for writing table | |
| KR101479516B1 (en) | Source code security weakness detection apparatus and method | |
| CN111078529B (en) | Client writing module testing method and device and electronic equipment | |
| CN110515653B (en) | Document generation method and device, electronic equipment and computer readable storage medium | |
| US8819645B2 (en) | Application analysis device | |
| KR101534493B1 (en) | Source code security weakness detection apparatus and method based on structure conversion | |
| CN113590446B (en) | Method and device for detecting numerical value file, electronic equipment and storage medium | |
| CN113176877B (en) | Entity class generation method, device and storage medium | |
| CN107015955B (en) | Document editing method and device | |
| JP6025955B1 (en) | Program analysis apparatus and program analysis method | |
| CN111273913B (en) | Method and device for outputting application program interface data represented by specifications |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |