CN109933365B - Method and device for generating function call tree - Google Patents
Method and device for generating function call tree Download PDFInfo
- Publication number
- CN109933365B CN109933365B CN201811627068.7A CN201811627068A CN109933365B CN 109933365 B CN109933365 B CN 109933365B CN 201811627068 A CN201811627068 A CN 201811627068A CN 109933365 B CN109933365 B CN 109933365B
- Authority
- CN
- China
- Prior art keywords
- function
- file
- recursive search
- target program
- call
- 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
Images
Abstract
The invention provides a method and a device for generating a function call tree, which are used for screening and distinguishing a function declaration file, a function realization file and a function call file in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the rename function by carrying out recursive search on the whole program and establishing a rename function table to determine the function name and the position so as to generate the function call tree.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a method and a device for generating a function call tree.
Background
In the software development process, after the function code is changed, the influence range of the function code change needs to be evaluated to evaluate whether the function code change can cause the compatibility problem, so that the test range can be more accurately guided. The existing call tree generation software embodies the call relation and the called relation in a relation window through a tree diagram, and when a user selects a certain function, the software outputs the call function of the function to a call relation tree and a called relation tree by searching the function in the function code.
However, the existing function call tree generation software can only generate the call relation and the called relation of a certain function, but cannot generate the function call relation, the called relation and the detailed call position sequence of the whole program. The conditions of missing macro definition functions and renaming functions of macro definition often occur, and only the function coverage rate can be ensured during analysis, but the call coverage rate cannot be ensured.
Disclosure of Invention
In view of this, the present invention is directed to a method for generating a function call tree, so as to solve the problem that the existing function call tree generation software can only generate the call and called relationships of a certain function, but cannot generate the function call relationship and called relationship of the whole program and the detailed call position sequence. The conditions of omitting macro definition functions and renaming functions of macro definition often occur, and the problems that only the function coverage rate can be ensured during analysis and the call coverage rate cannot be ensured exist.
In order to achieve the purpose, the technical scheme of the invention is realized as follows:
a method of generating a function call tree, the method comprising:
screening and distinguishing function statement files, function realization files and function calling files in the target program;
screening and distinguishing macro definitions in the target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table;
determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table;
performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result;
and generating a function call tree according to the recursive search result and the position corresponding to the function name.
Further, before the step of screening and distinguishing the function declaration file, the function implementation file, and the function call file in the target program, the method further includes:
and recursively searching reference relations among all functions of the target program, and establishing a reference relation table.
Further, the performing a recursive search on the target program according to the function declaration file, the function implementation file, and the renaming function table to obtain a recursive search result includes:
and according to the function statement file, the reference relation table and the renaming function table, starting recursive search from a root node of a function call subtree of the target program, inquiring a called function name of the next step according to the reference relation table, and stopping and obtaining a recursive search result until the called function name is not found in the reference relation table.
Further, after the step of determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table, the method further includes:
and classifying the calling functions according to the function names, establishing a function calling sub-tree for each type of calling functions, and connecting the other calling functions of the same type through a linked list.
Further, the performing recursive search on the target program according to the function declaration file, the function implementation file, and the renaming function table to obtain a recursive search result further includes:
by searching records, the recursive search of the called function which is searched is omitted.
Compared with the prior art, the method for generating the function call tree has the following advantages:
the invention provides a method for generating a function call tree, which screens and distinguishes a function declaration file, a function realization file and a function call file in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the rename function by carrying out recursive search on the whole program and establishing a rename function table to determine the function name and the position so as to generate the function call tree.
Another objective of the present invention is to provide a device for generating a function call tree, so as to solve the problem that the existing function call tree generation software can only generate the call and called relations of a certain function, and cannot generate the function call relation and called relation of the whole program and the detailed call position sequence. The conditions of omitting macro definition functions and renaming functions of macro definition often occur, and the problems that only the function coverage rate can be ensured during analysis and the call coverage rate cannot be ensured are solved.
In order to achieve the purpose, the technical scheme of the invention is realized as follows:
an apparatus for generating a function call tree, the apparatus comprising:
the file screening module is used for screening and distinguishing function statement files, function realization files and function calling files in the target program;
the macro definition screening module is used for screening and distinguishing the macro definitions in the target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table;
the confirming module is used for determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table;
the recursive search module is used for performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result;
and the function call tree generating module is used for generating a function call tree according to the recursive search result and the position corresponding to the function name.
Further, before the file screening module, the method further includes:
and the reference relation module is used for recursively searching the reference relation among all the functions of the target program and establishing a reference relation table.
Further, the recursive search module includes:
and the recursive search submodule is used for starting recursive search from a root node of a function call subtree of the target program according to the function statement file, the reference relation table and the renaming function table, inquiring a called function name of the next step according to the reference relation table, and stopping and acquiring a recursive search result until the called function name is not found in the reference relation table.
Further, after the confirmation module, the method further includes:
and the function calling sub-tree module is used for classifying the calling functions according to the function names, establishing a function calling sub-tree for the calling functions of each type, and connecting the rest calling functions of the same type through a linked list.
Further, the recursive search module is further configured to omit performing a recursive search on the searched called function by searching for a record.
Compared with the prior art, the function call tree generation device has the following advantages:
the invention provides a method for generating a function call tree, which screens and distinguishes function statement files, function realization files and function call files in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining a function name of each calling function and a corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the rename function by carrying out recursive search on the whole program and establishing a rename function table to determine the function name and the position so as to generate the function call tree.
Compared with the prior art, the device for generating the function call tree and the method for generating the function call tree have the same advantages, and are not described again.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention, illustrate embodiments of the invention and together with the description serve to explain the invention and do not constitute a limitation of the invention. In the drawings:
fig. 1 is a flowchart illustrating steps of a method for generating a function call tree according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating steps of another method for generating a function call tree according to an embodiment of the present invention;
fig. 3 is a block diagram of a function call tree generation apparatus according to an embodiment of the present invention.
Detailed Description
It should be noted that the embodiments and features of the embodiments may be combined with each other without conflict.
The present invention will be described in detail below with reference to the accompanying drawings in conjunction with embodiments.
Fig. 1 is a flowchart illustrating steps of a method for generating a function call tree according to an embodiment of the present invention, where the method may include:
and 101, screening and distinguishing function statement files, function realization files and function calling files in the target program.
And 102, screening and distinguishing macro definitions in the target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table.
And 103, determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table.
And 104, performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result.
And 105, generating a function call tree according to the recursive search result and the position corresponding to the function name.
The invention provides a method for generating a function call tree, which screens and distinguishes function statement files, function realization files and function call files in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining a function name of each calling function and a corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the renamed functions by carrying out recursive search on the whole program and establishing a renamed function table to determine the function name and the position so as to generate the function call tree.
Referring to fig. 2, a method for generating a function call tree according to another embodiment of the present invention is shown, where the method may include:
In the embodiment of the invention, the target program is recursively searched before generating the function call tree, all function implementation files of the target program are inquired, the reference relation among all functions of the target program is determined, and a reference relation table of all functions is established. And storing the reference relation table in a database for standby use, wherein the database can be a small database and can meet the requirement of a search function, and the storage capacity only needs to meet the requirement of temporarily storing the reference relation table. The target program may be all codes of the whole project, or all codes of a certain target software, and may be adaptively adjusted according to specific situations, which is not limited herein.
In the embodiment of the invention, all files of the target program are screened, and the function statement file, the function realization file and the function call file are distinguished for being used for subsequently generating the function call tree, so that the generation efficiency of the function call tree is accelerated.
In the embodiment of the invention, the macro definition of the target program is screened, a compiling instruction, a constant instruction, a macro definition function and a macro definition function are distinguished and renamed, then the constant definition and irrelevant compiling instructions in the macro definition are proposed, and finally all the macro definition functions are integrated and renamed to establish a renaming function table.
And 204, determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table.
In the embodiment of the invention, all the transfer function names of the target program and the corresponding positions of the function names are searched according to the function call file, and the original function names of all the function names are determined according to the renaming function table.
In the embodiment of the invention, all function names of the target program are classified, a function call subtree is established for the call functions with the same function name, and the function names of the call functions are connected in a linked list mode for the call functions of the same class which do not completely accord with the call functions of the corresponding function call subtree. And accelerating the efficiency of subsequently generating a call tree by preliminarily generating the call function subtree.
And step 206, performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result.
In the embodiment of the invention, the function declaration file is inquired to determine the root node of the function call subtree, and the function realization file and the renaming function table are inquired from the root node of the call subtree to perform recursive search to obtain a search result.
Further, the step 206 may include:
step 2061, according to the function declaration file, the reference relation table and the renaming function table, starting recursive search from a root node of a function calling sub-tree of the target program, and inquiring a called function name of the next step according to the reference relation table until the called function name is not found in the reference relation table, and stopping and obtaining a recursive search result.
In the embodiment of the present invention, after the function declaration file is queried to determine the root node of the function call subtree, the reference relationship table established in query step 201 is used to compare with the renaming function table to perform recursive search, the next called function name is queried in the reference relationship table, and the recursive search is stopped until the called function name is not found in the reference relationship table, and the search result is obtained. This can greatly reduce the efficiency of generating the function call tree.
Further, the step 206 may further include omitting the recursive search of the searched called function by searching the record.
In the embodiment of the invention, in the process of recursive search, the recursive search is recorded, and the recursive search is stopped for the searched calling function subtrees, so that the recursive times are reduced, and the efficiency of generating the function call tree is accelerated.
And step 207, generating a function call tree according to the recursive search result and the position corresponding to the function name.
In the embodiment of the invention, a function call tree of the target function is established and generated according to the function call relation and the position sequence in the search result. And a function call tree for outputting the target function can be exported through a file.
The invention provides a method for generating a function call tree, which screens and distinguishes function statement files, function realization files and function call files in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining a function name of each calling function and a corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the rename function by carrying out recursive search on the whole program and establishing a rename function table to determine the function name and the position so as to generate the function call tree.
Referring to fig. 3, a block diagram of a device 30 for generating a function call tree according to an embodiment of the present invention is shown, where the device may include:
a file screening module 301, configured to screen and distinguish function declaration files, function implementation files, and function call files in the target program;
a macro definition screening module 302, configured to screen and distinguish macro definitions in the target program, remove constant definitions and irrelevant compiling instructions in the macro definitions, and establish a renaming function table;
a confirming module 303, configured to determine, according to the function call file and the rename function table, a function name of each call function and a position corresponding to the function name;
a recursive search module 304, configured to perform recursive search on the target program according to the function declaration file, the function implementation file, and the renaming function table, and obtain a recursive search result;
and a function call tree generating module 305, configured to generate a function call tree according to the recursive search result and the location corresponding to the function name.
Further, before the file screening module 301, the method further includes:
and the reference relation module is used for recursively searching the reference relation among all the functions of the target program and establishing a reference relation table.
Further, the recursive search module 304 includes:
and the recursive search submodule is used for starting recursive search from a root node of a function call subtree of the target program according to the function statement file, the reference relation table and the renaming function table, inquiring a called function name of the next step according to the reference relation table, and stopping and acquiring a recursive search result until the called function name is not found in the reference relation table.
Further, after the confirming module 303, the method further includes:
and the function call subtree module is used for classifying the call functions according to the function names, establishing a function call subtree for the call functions of each class, and connecting the other call functions of the same class through a linked list.
Further, the recursive search module 303 is further configured to omit performing a recursive search on the searched called function by searching for a record.
The invention provides a method for generating a function call tree, which screens and distinguishes function statement files, function realization files and function call files in a target program; screening and distinguishing macro definitions in a target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table; determining a function name of each calling function and a corresponding position of the function name according to the function calling file and the renaming function table; performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result; and generating a function call tree according to the recursive search result and the position corresponding to the function name. The method of the invention not only realizes the generation of the function call tree of the whole program, but also ensures the position sequence among the call functions and the integrity of the renamed functions by carrying out recursive search on the whole program and establishing a renamed function table to determine the function name and the position so as to generate the function call tree.
It can be clearly understood by those skilled in the art that, for convenience and simplicity of description, the specific working processes of the above-described apparatuses and modules may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.
Other embodiments of the invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of the invention following, in general, the principles of the invention and including such departures from the present disclosure as come within known or customary practice within the art to which the invention pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the invention being indicated by the following claims.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents, improvements and the like that fall within the spirit and principle of the present invention are intended to be included therein.
Claims (10)
1. A method for generating a function call tree, the method comprising:
screening and distinguishing function statement files, function realization files and function calling files in a target program;
screening and distinguishing macro definitions in the target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table;
determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table;
performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result;
and generating a function call tree according to the recursive search result and the position corresponding to the function name.
2. The method according to claim 1, wherein the step of screening to distinguish the function declaration file, the function realization file, and the function calling file in the target program is preceded by the steps of:
and recursively searching reference relations among all functions of the target program, and establishing a reference relation table.
3. The method according to claim 2, wherein performing a recursive search on the target program according to the function declaration file, the function implementation file, and the renaming function table to obtain a recursive search result comprises:
and according to the function statement file, the reference relation table and the renaming function table, starting recursive search from a root node of a function call subtree of the target program, inquiring a called function name of the next step according to the reference relation table, and stopping and obtaining a recursive search result until the called function name is not found in the reference relation table.
4. The method of claim 1, wherein after the step of determining a function name and a corresponding location of the function name for each calling function according to the function call file and the rename function table, the method further comprises:
and classifying the calling functions according to the function names, establishing a function calling sub-tree for the calling functions of each class, and connecting the other calling functions of the same class through a linked list.
5. The method of claim 1, wherein the recursively searching the target program according to the function declaration file, the function implementation file, and the renaming function table to obtain a recursive search result, further comprises:
by searching the records, the recursive search of the called functions that have already been searched is omitted.
6. An apparatus for generating a function call tree, the apparatus comprising:
the file screening module is used for screening and distinguishing function statement files, function realization files and function calling files in the target program;
the macro definition screening module is used for screening and distinguishing the macro definitions in the target program, removing constant definitions and irrelevant compiling instructions in the macro definitions, and establishing a renaming function table;
the confirming module is used for determining the function name of each calling function and the corresponding position of the function name according to the function calling file and the renaming function table;
the recursive search module is used for performing recursive search on the target program according to the function statement file, the function implementation file and the renaming function table to obtain a recursive search result;
and the function call tree generation module is used for generating a function call tree according to the recursive search result and the position corresponding to the function name.
7. The apparatus of claim 6, wherein the file filtering module is preceded by:
and the reference relation module is used for recursively searching the reference relation among all the functions of the target program and establishing a reference relation table.
8. The apparatus of claim 7, wherein the recursive search module comprises:
and the recursive search submodule is used for starting recursive search from a root node of a function call subtree of the target program according to the function statement file, the reference relation table and the renaming function table, inquiring a called function name of the next step according to the reference relation table, and stopping and acquiring a recursive search result until the called function name is not found in the reference relation table.
9. The apparatus of claim 6, wherein the confirmation module is followed by further comprising:
and the function call subtree module is used for classifying the call functions according to the function names, establishing a function call subtree for the call functions of each class, and connecting the other call functions of the same class through a linked list.
10. The apparatus of claim 6, wherein the recursive search module is further configured to omit recursive searching for the searched called function by searching for records.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811627068.7A CN109933365B (en) | 2018-12-28 | 2018-12-28 | Method and device for generating function call tree |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811627068.7A CN109933365B (en) | 2018-12-28 | 2018-12-28 | Method and device for generating function call tree |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109933365A CN109933365A (en) | 2019-06-25 |
| CN109933365B true CN109933365B (en) | 2022-08-19 |
Family
ID=66984876
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811627068.7A Active CN109933365B (en) | 2018-12-28 | 2018-12-28 | Method and device for generating function call tree |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109933365B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112445512A (en) * | 2019-08-29 | 2021-03-05 | 上海高德威智能交通系统有限公司 | Hotspot analysis method and device for program codes |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1614563A (en) * | 2003-11-05 | 2005-05-11 | 松下电器产业株式会社 | Template compilation method |
| CN101697121A (en) * | 2009-10-26 | 2010-04-21 | 哈尔滨工业大学 | Method for detecting code similarity based on semantic analysis of program source code |
| CN102810078A (en) * | 2011-06-02 | 2012-12-05 | 兰州大学 | Method for analyzing dynamic execution of Linux kernel |
| CN103729580A (en) * | 2014-01-27 | 2014-04-16 | 国家电网公司 | Method and device for detecting software plagiarism |
| CN107085533A (en) * | 2017-03-27 | 2017-08-22 | 北京北大软件工程股份有限公司 | A kind of analysis method and system of pointer modified influence |
| CN108132799A (en) * | 2017-12-25 | 2018-06-08 | 首都师范大学 | Interprocedual static program analysis information extracting method, device and equipment |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103186406B (en) * | 2011-12-30 | 2016-08-17 | 国际商业机器公司 | Method and apparatus for control flow analysis |
-
2018
- 2018-12-28 CN CN201811627068.7A patent/CN109933365B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1614563A (en) * | 2003-11-05 | 2005-05-11 | 松下电器产业株式会社 | Template compilation method |
| CN101697121A (en) * | 2009-10-26 | 2010-04-21 | 哈尔滨工业大学 | Method for detecting code similarity based on semantic analysis of program source code |
| CN102810078A (en) * | 2011-06-02 | 2012-12-05 | 兰州大学 | Method for analyzing dynamic execution of Linux kernel |
| CN103729580A (en) * | 2014-01-27 | 2014-04-16 | 国家电网公司 | Method and device for detecting software plagiarism |
| CN107085533A (en) * | 2017-03-27 | 2017-08-22 | 北京北大软件工程股份有限公司 | A kind of analysis method and system of pointer modified influence |
| CN108132799A (en) * | 2017-12-25 | 2018-06-08 | 首都师范大学 | Interprocedual static program analysis information extracting method, device and equipment |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109933365A (en) | 2019-06-25 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106469049B (en) | File scanning method and device | |
| CN105138312B (en) | A kind of table generation method and device | |
| CN111241073B (en) | Data quality inspection method and device | |
| US6205576B1 (en) | Method and apparatus for identifying indirect messaging relationships between software entities | |
| CN106599167B (en) | System and method for supporting increment updating of database | |
| CN104461531A (en) | Implementing method for self-defined functions of reporting system | |
| CN107562485B (en) | Method and device for automatically collecting patch data | |
| CN113312374A (en) | Data query method, device, equipment and storage medium | |
| CN109933365B (en) | Method and device for generating function call tree | |
| CN108897678B (en) | Static code detection method, static code detection system and storage device | |
| CN113568604B (en) | Method and device for updating wind control strategy and computer readable storage medium | |
| CN111125213A (en) | Data acquisition method, device and system | |
| CN110134583B (en) | Software testing and data processing method and device | |
| CN109343855B (en) | Program compiling and grabbing system and method based on instruction camouflage | |
| CN116541278A (en) | Unit test case generation method, device, equipment and storage medium | |
| CN115982416A (en) | Data processing method and device, readable storage medium and electronic equipment | |
| CN105893445A (en) | Data processing method, server and terminal device | |
| CN115757479A (en) | Database query optimization method, machine-readable storage medium and computer device | |
| US11775643B2 (en) | Method and system for labeling object and generating security policy of operating system | |
| CN112799673B (en) | Network protocol data checking method and device | |
| CN111443920B (en) | Frame migration method and device | |
| CN113805960B (en) | YAML-based server configuration method, device, terminal and storage medium | |
| CN111124542A (en) | Configuration information management system | |
| CN111273944B (en) | Method and device for generating program file and uploading program file to code warehouse | |
| CN114647589A (en) | Application software testing method, system, device, equipment and readable storage medium |
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 |