CN116302919A - Multi-language extensible code dependency analysis model and analysis method - Google Patents
Multi-language extensible code dependency analysis model and analysis method Download PDFInfo
- Publication number
- CN116302919A CN116302919A CN202211516728.0A CN202211516728A CN116302919A CN 116302919 A CN116302919 A CN 116302919A CN 202211516728 A CN202211516728 A CN 202211516728A CN 116302919 A CN116302919 A CN 116302919A
- Authority
- CN
- China
- Prior art keywords
- dependency
- entity
- information
- code
- syntax tree
- 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.)
- Pending
Links
- 238000004458 analytical method Methods 0.000 title claims abstract description 35
- 238000000034 method Methods 0.000 claims abstract description 48
- 230000008569 process Effects 0.000 claims abstract description 14
- 238000000605 extraction Methods 0.000 claims abstract description 13
- 230000008676 import Effects 0.000 claims abstract description 7
- 238000012545 processing Methods 0.000 claims description 25
- 230000003068 static effect Effects 0.000 claims description 11
- 230000001419 dependent effect Effects 0.000 claims description 10
- 239000000284 extract Substances 0.000 claims description 3
- 125000004122 cyclic group Chemical group 0.000 claims description 2
- 238000013461 design Methods 0.000 claims description 2
- 238000003860 storage Methods 0.000 abstract description 10
- 230000006870 function Effects 0.000 description 11
- 238000010586 diagram Methods 0.000 description 10
- 238000004590 computer program Methods 0.000 description 7
- 238000011161 development Methods 0.000 description 4
- 238000011160 research Methods 0.000 description 3
- 230000002776 aggregation Effects 0.000 description 1
- 238000004220 aggregation Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005265 energy consumption Methods 0.000 description 1
- 238000002372 labelling Methods 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000005259 measurement 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
- 238000007781 pre-processing Methods 0.000 description 1
- 238000002360 preparation method Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 239000013589 supplement Substances 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3604—Software analysis for verifying properties of programs
- G06F11/3608—Software analysis for verifying properties of programs using formal methods, e.g. model checking, abstract interpretation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/80—Information retrieval; Database structures therefor; File system structures therefor of semi-structured data, e.g. markup language structured data such as SGML, XML or HTML
- G06F16/81—Indexing, e.g. XML tags; Data structures therefor; Storage structures
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention discloses a multi-language extensible code dependency analysis model and an analysis method, which are characterized in that firstly, an abstract syntax tree is generated by utilizing an analyzer, information is acquired at proper nodes based on traversal of the abstract syntax tree, extraction and storage of an entity are completed, secondly, a plurality of directly-judged dependency relationships and incomplete dependencies capable of judging half of information are reserved in the process, finally, the incomplete dependencies obtained in analysis of a preamble flow are processed, and in combination with a symbol table, dependency backfilling is completed according to the sequence of 'Export before Import and then other', incomplete dependencies completing dependency backfilling are complemented into complete dependency storage, and incomplete dependencies failing in dependency backfilling are reserved into unresolved dependency storage.
Description
Technical Field
The invention relates to the field of trusted software and static code analysis, in particular to the field of language-independent, test item application scene-independent and extensible static code dependency analysis.
Background
The static code analysis is an important component in the field of software engineering, the software product needs to carry out static code analysis in the development and maintenance processes, and a dependence analysis result obtained by the static code analysis provides a solid foundation for upper-layer software and architecture analysis, so that the method can be widely applied to multiple fields of vulnerability detection, architecture measurement, bad software taste and the like, and can ensure the reliability and safety of the software product. Static code analysis does not require running a software product, which has better performance in terms of time complexity and space complexity than dynamic analysis.
The academic research is often focused on certain specific languages, and is biased to call (call) dependency graph construction and analysis under specific scenes (such as Linux operating system), the entity granularity is relatively coarse, the analysis is often performed on a function level, the dependency types are relatively few, and the dependency types are focused on calling relations and inheritance relations. Finer granularity entities and more kinds of dependencies can provide more information-rich, providing a robust support for upper level applications such as architectural metrics. At present, research in the industry is often designed based on own needs, development perfection is higher, tools which are used for external opening are mostly closed sources and charged projects, cost is higher, openness is poor, the projects are lower in accuracy in partial scenes due to the reasons of language grammar standard diversity, incapability of determining the type of an accepted object in the compiling period and the like, supplement and iterative development cannot be carried out, the rest projects are mostly early stages of development, supported functions are fewer, and capability is weak. Some protocols for describing the intermediate results of static analysis exist at present, but the popularity and the use degree are insufficient, and the feasibility of the protocols is difficult to verify.
Disclosure of Invention
The invention aims to provide a multi-language and extensible code dependency analysis method which can achieve a certain balance in ordering performance and time cost, can achieve the advantages of both performance and time cost in large-scale software, and overcomes the defects that a program has to have no running errors and consumes calculation power and time in dynamic code analysis by utilizing a static code analysis mode so as to solve the technical problems.
In order to achieve the purpose, the invention is realized by adopting the following technical scheme:
s1 traversing file system
S2 generating abstract syntax tree
S3 entity extraction based on abstract syntax tree traversal
S4, intermediate processing according to entity extraction results
S5 dependency backfilling based on symbol table
S6, generating and outputting a result
A multi-lingual extensible code-dependent analytical model comprising:
the code dependency graph model consists of nodes and edges, wherein the nodes represent entity objects, store all information related to the entities, including but not limited to types, unique identification indexes, full names, attribute information and position information of the entities, the edges are bridges between two entities which link to generate dependency, the edges are directed edges, the direction of the edges refers to the direction of the dependency, namely, a certain dependency relationship between a source entity and a destination entity occurs, and besides, the edges also retain other information related to the dependency, including but not limited to types of the dependency and the occurrence position of the dependency.
A multi-language extensible code dependency analysis method traverses a file system module, traverses an input project path and obtains file information and processing sequence to be processed;
the abstract syntax tree generating module is used for setting proper compiling options according to the file list and the processing sequence to generate an abstract syntax tree;
the entity extraction module based on the abstract syntax tree extracts entity information from corresponding nodes on the abstract syntax tree according to the generated abstract syntax tree and a visitor design mode;
the intermediate processing module is used for carrying out identification resolution on incomplete processing information in the entity list;
the dependency backfilling module is based on the symbol table, and a final entity dependency graph is obtained according to the entity information in the entity warehouse and the incomplete dependency completion entity information obtained through processing;
and a result output module.
Each node in the dependency graph can confirm a unique entity, and complex conditions such as multiple times of dependency occurrence or simultaneous occurrence of multiple dependencies are allowed to exist between the nodes, namely edges can be overlapped, in addition, association relation exists between dependency information, cyclic dependency/indirect dependency is deduced according to the dependency information, the occurrence position of the dependency can be in an entity definition file or not, and the occurrence position of the dependency, the definition positions of a source entity and a destination entity can be in different files.
The method optimizes the internal storage structure and processing logic, and can complete analysis in ideal time and space for large-scale software products with complex dependency relationships.
For other forms to be analyzed and other related kinds of dependence are needed, the abstract syntax tree generated in the method process can be expanded, the whole framework is isolated clearly, and the module expansion is allowed to be supported in a friendly mode.
There is no limitation on the language of the input software product, and the method has good robustness on tolerating grammar errors and semantic errors of the software product.
The extracted entity granularity is the entity of the symbol level, the granularity is finer, the reserved entity information takes the variable as the minimum entity level, and the reserved dependency information takes the dependency information occurring between the entities as the minimum dependency level.
Finer granularity information formats, including entities being object structures with attributes including, but not limited to, name, code location, and type, may have sub-division types in addition to types, reflecting finer granularity entity characteristics:
the universality of the dependency types, including dynamic dependency, static dependency and the like;
depending on the backfill sequence, including the comprehensive symbol table, the dependency backfill is completed according to the sequence of 'Export before Import and other last', and incomplete dependencies completing the dependency backfill are complemented into complete dependency storage.
Compared with the prior art, the invention has the following beneficial effects:
the invention relates to a multi-language extensible code dependency analysis method, which comprises the steps of firstly, utilizing an analyzer to generate an abstract syntax tree, acquiring information at proper nodes based on traversal of the abstract syntax tree, completing extraction and storage of entities, secondly, reserving a plurality of directly-judged dependency relationships and incomplete dependencies capable of judging half of information in the process, finally, processing the incomplete dependencies obtained in analysis of a preamble flow, completing dependency backfilling according to the sequence of 'Export first and Import last and the other', completing the incomplete dependencies of the dependency backfilling, and reserving the incomplete dependencies of the dependency backfilling failure as unresolved dependency storage.
Drawings
FIG. 1 is a diagram of an entity-dependent classification of a multi-language extensible code-dependent parsing method according to an embodiment of the invention;
FIG. 2 is a flowchart of a multi-language extensible code dependency parsing method according to an embodiment of the present invention, wherein the flowchart includes three sub-graphs, sub-graph (a) is a flowchart overall diagram, sub-graph (b) is a dependency backfill flowchart, sub-graph (c) is an extension module, and an implicit dependency extraction flowchart;
FIG. 3 is a diagram of a multilingual extensible entity-dependent model in accordance with an embodiment of the present invention.
Detailed Description
In order that those skilled in the art will better understand the present invention, a technical solution in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in which it is apparent that the described embodiments are only some embodiments of the present invention, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the present invention without making any inventive effort, shall fall within the scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and the claims of the present invention and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the invention described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
The invention is described in further detail below with reference to the attached drawing figures:
referring to fig. 1, the embodiments of the present invention are divided into 3 types shown in (a) - (c) and 3 types shown in (d) - (f), respectively, for all possible entities and dependencies according to their properties, extraction modes, etc. For entities, FIG. 1 (a) is a partial structural entity, which is typically a constituent file of a software project and a folder with a particular schema for the portion; FIG. 1 (b) is a partial code entity, typically an element of a software project code file that conforms to a particular syntax format and that bears specific software functional logic; FIG. 1 (c) is a partial scope entity, which is typically an element in a software project code file that conforms to a particular syntax format but performs only a logical control flow conversion function. For dependencies, FIG. 1 (d) is a partial binding-free dependency, which is generally a dependency that can be fully resolved simultaneously with entity extraction in traversing a code abstract syntax tree; FIG. 1 (e) is a partial binding-required dependency, which is typically a dependency that cannot be fully resolved when traversing a code abstract syntax tree, and typically requires a subsequent secondary analysis to find the entity to which the dependency points from the code string; FIG. 1 (f) is a partial implicit dependency that is typically constructed by reversing the possible types of a variable in a programming language of a type-less labeling system based on the subsequent use of the attribute by the variable, and compared to the aforementioned dependencies, implicit dependency resolution requires additional steps to achieve solution and constraint refinement.
Referring to fig. 2 (a), in the general flow chart of the embodiment of the present invention, the input of the method includes item source codes, item configuration, third party library list, etc., and the output is entity warehouse, dependency warehouse, custom analysis result (if any), etc., and specifically includes the following procedures:
the preparation work selects the proper resolver. The method needs to research the existing resolvers, the selected resolvers need to be capable of generating abstract syntax trees with high efficiency, high accuracy and low energy consumption under the fault tolerance condition, the resolvers need to be tools which are commonly known in industry and are generally verified and timely maintained according to language version changes, for example, the invention adopts Eclipse JDT and CDT for Java and C++ languages respectively, adopts language official parser for Python and adopts babel for Javascript and TypeScript.
S1, traversing the software project catalog to obtain all structural entities. Specifically, the method comprises the following steps:
s101: given a plurality of directory paths of a software project, firstly traversing all files in a directory by using a tree traversal algorithm, and respectively creating File entities for a programming language source File, a configuration File of a specific programming language or a framework and other files which can influence dependence analysis;
s102: for a directory structure with a specific functional meaning in a part of specific programming languages, for example, a directory containing __ init __ in Python is specialized to Python Module and a directory containing Package json file in JavaScript is specialized to node js Package, and a corresponding structural entity is additionally created for the directory structure. If a structural entity has a corresponding configuration file, information which can influence the analysis of the dependence in the configuration file is stored in the entity in the form of attributes.
S2, traversing the code abstract syntax tree nodes to obtain all code entities and scope entities. Specifically, the method comprises the following steps:
s201: preprocessing links defined by a particular programming language. If there is an activity involving writing a code file in a particular programming language, embodiments of the present invention will perform the same writing in the relevant definition herein. Such as C/c++ requires processing all header files (h files) before processing (macro-expansion) other code files, and also requires accessing and parsing specific program environment variables, etc.
S202: and (3) analyzing the content of the code File corresponding to the File entity obtained in the S101 into a code abstract syntax tree by using a Parser. According to the different Parser used, the step can analyze the single file one by one, or directly analyze the whole abstract syntax tree at one time by using the API provided by the specific Parser for establishing the whole abstract syntax tree for the whole project at one time;
s203: and traversing all the code abstract syntax tree nodes in sequence by using a node traversing interface based on a visitor mode provided by the Parser, and registering corresponding extraction methods for the abstract syntax tree nodes respectively corresponding to each code entity and each scope entity. A particular extraction method can create an entity of its type when called and extract the required information from the corresponding abstract syntax tree node to save in that entity. In the process, all entities are stored in a hierarchical manner according to the code scope containing relation;
s204: the context information stack across the nodes is initialized and maintained continuously with the node traversal process of S203. The property computation of the current node depends on the correlation property of the brother node of the same layer or the father-child node crossing multiple layers, and the node traversing interface provided by the Parser is normally stateless, so that a stack structure capable of maintaining and transmitting specific information when the node jumps is additionally used;
s205: part does not need immediate resolution of binding dependencies. The grammar mode of the specific programming language enables the entity to be bound to actually appear behind the grammar identifier of the specific dependency, and when traversing the abstract grammar tree node in sequence, the entity to be bound can be created and bound according to S203, so that the entity to be bound can be created and bound to become a complete dependency;
s206: binding records of dependencies (incomplete dependencies) is required. In contrast to S204, most grammar patterns have the entity to be bound present in front of the grammar identifier of a particular dependency, and only references to that entity in the form of a string are obtained while traversing to that dependency' S grammar identifier, which string needs to be parsed into the entity saved in S203 in a subsequent step, whereas in this step only the incomplete dependency (incomplete dependency) and other relevant information contributing to the binding can be temporarily saved in a separate structure.
S3, performing intermediate processing according to the entity extraction result. And (3) finishing the entity attribute information stored in the process that the entity fails to process because the entity is not completely extracted in the step (2). For example: (1) Binding type information of the object defined by the data aggregation entity; and (2) realizing the identification and recording of the function reloading information and the like.
S4, dependent binding based on a hierarchical symbol table. Traversing the incomplete dependency recorded in step 2 according to the sequence of Export-Import-other, and complementing the dependency relationship according to the module path analysis rule, the scope-based symbol table hierarchical search and other methods. Specifically, the method comprises the following steps:
s401: processing binding information which can be solved by the abstract syntax tree, filling back and forth the dependency in the same file according to the binding information provided by the abstract syntax tree, and storing the dependency in a dependency warehouse;
s402: handling dependencies across and unbound to files, this process looks up backfills from the symbol table. A categorization discussion is made here: firstly, according to language requirements, searching whether corresponding Export dependence exists on the Import dependence or not; secondly, classifying according to life cycle, searching by adopting a method of searching step by step upwards according to a scope for the condition that a target binding entity is a function/class and the like, searching in a file with a reference relation (Import, include and the like) after searching fails, and finally searching Built-in building-in entities of a programming language; for entities such as local variables with life cycle limitation, the memory is released when the local scope is finished and is not accessed by an external entity, so that only short names are used for setting, and only the current scope or an upper scope is searched in the searching process and then bound. The dependency information which is successfully bound is used as complete dependency and is stored in an entity warehouse, the dependency information which is failed to be bound is classified as unknown dependency, the reasons for the unknown dependency include but are not limited to the conditions that the call of a standard API is inconsistent with the version of a third party library, and the like, the entity which is not bound in the dependency warehouse can be also added to be stored, and the entity which is not bound in the dependency warehouse can be marked as unresolved, and the dependency is also marked as unresolved.
Referring to FIG. 2 (b), a flow chart of dependency binding for incomplete dependencies in an embodiment of the method is shown. In general with respect to dependency binding, steps that may be implemented are local scope search, module path resolution, extended scope search, imported scope search, three-way library list search, and language build-in list search, and different types of dependencies may use a single or multiple of all of the above steps, respectively. For all incomplete dependencies recorded by S206, the processing is performed in a specific processing sequence by type before processing, generally following the order of "Export before Import and then other". The steps required to handle each type of dependency are identified in the figure as either "v" (single step) or numerical (steps performed in numerical order).
The following is an explanation and explanation of the scalability of the method:
referring to fig. 2 (c), an example of an extensible part of the method embodiment is shown, in this embodiment, as an implicit dependency extraction module. Implicit dependencies are dependencies that are difficult to index through conventional static code analysis, which can only be obtained through dynamic analysis in the normal case. In the present method, the semantics may be abstracted by means of the generated AST, for example x=y may be denoted as Move (x, y), x.f =y may be denoted as Store (x, f, y); from semantic abstraction, the explicit dependencies mentioned above, and the constructed heap model, resolved code dependencies from directed relationships can be obtained, specifying implicit dependencies constrained by member calls, etc.
Referring to fig. 3, an entity dependency model diagram in the embodiment of the method is shown, where an entity is an object structure with attributes including, but not limited to, name (Name), code Location (Location), type (Type), and the like, and may have a Sub-Type (Sub-Type) in addition to the Type, which reflects the more fine-grained entity characteristics; dependence d=<E src ,Type,E dest >Is a triple structure comprising a start entity, a dependent type and a termination entityIt also has attributes including, but not limited to, code Location (Location). The model is a traditional simple enumeration model { E= { E a ,E b ,…},D＝{D a ,D b … }. Using the starting entity type and the ending entity type in the dependency triplet structure, homonymous dependencies that may occur between multiple entity pairs are partitioned into different two-dimensional coordinates (E src ,E dest ) And (3) downwards. The entity dependency model not only can display complete entity and dependency type classification, but also can clearly display what kind of dependency fine-grained relation can be generated between what kind of entities, and has the function of prompting attention to avoid omission when guiding the realization of coding.
The division of the modules in the embodiments of the present invention is schematically only one logic function division, and there may be another division manner in actual implementation, and in addition, each functional module in each embodiment of the present invention may be integrated in one processor, or may exist separately and physically, or two or more modules may be integrated in one module. The integrated modules may be implemented in hardware or in software functional modules.
It will be appreciated by those skilled in the art that 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 flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations 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 means 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 instruction means 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.
Finally, it should be noted that: the above embodiments are only for illustrating the technical aspects of the present invention and not for limiting the same, and although the present invention has been described in detail with reference to the above embodiments, it should be understood by those of ordinary skill in the art that: modifications and equivalents may be made to the specific embodiments of the invention without departing from the spirit and scope of the invention, which is intended to be covered by the claims.
Claims (10)
1. A multi-lingual extensible code-dependent analytical model comprising:
the code dependency graph model consists of nodes and edges, wherein the nodes represent entity objects, store all information related to the entities, including but not limited to types, unique identification indexes, full names, attribute information and position information of the entities, the edges are bridges between two entities which link to generate dependency, the edges are directed edges, the direction of the edges refers to the direction of the dependency, namely, a certain dependency relationship between a source entity and a destination entity occurs, and besides, the edges also retain other information related to the dependency, including but not limited to types of the dependency and the occurrence position of the dependency.
2. The multi-language extensible code dependency analysis method adopting the model according to claim 1, wherein the file system module is traversed, the input project path is traversed, and file information and processing sequence to be processed are obtained;
the abstract syntax tree generating module is used for setting proper compiling options according to the file list and the processing sequence to generate an abstract syntax tree;
the entity extraction module based on the abstract syntax tree extracts entity information from corresponding nodes on the abstract syntax tree according to the generated abstract syntax tree and a visitor design mode;
the intermediate processing module is used for carrying out identification resolution on incomplete processing information in the entity list;
the dependency backfilling module is based on the symbol table, and a final entity dependency graph is obtained according to the entity information in the entity warehouse and the incomplete dependency completion entity information obtained through processing;
and a result output module.
3. The multi-language extensible code dependency analysis method according to claim 2, wherein each node in the dependency graph can confirm a unique entity, complex situations such as multiple times of dependency occurrence or multiple kinds of dependency occurrence are allowed to exist between the nodes, namely edges can overlap, in addition, an association relation exists between dependency information, cyclic dependency/indirect dependency is deduced according to the dependency information, the occurrence position of the dependency can be in an entity definition file or not, and the occurrence position of the dependency and the definition positions of a source entity and a destination entity can be in different files.
4. A multi-lingual extensible code-dependent parsing method according to claim 2, wherein the method optimizes internal memory structures and processing logic, and wherein the method can accomplish parsing in ideal time and space for software products that are large-scale and have complex dependencies.
5. The multi-language extensible code dependency parsing method according to claim 2, wherein the abstract syntax tree generated in the process of the method can be expanded under the condition that other forms need to be parsed and other related kinds of dependencies are needed, the whole framework is isolated clearly, and the module expansion is allowed to be supported in a friendly mode.
6. A multi-lingual extensible code-dependent parsing method according to claim 2, characterized in that the method is not limited to the language of the input software product, and has good robustness to tolerating syntax errors and semantic errors of the software product.
7. The method of claim 2, wherein the extracted entities have a granularity of symbol level, the granularity is finer, the reserved entity information has a variable as a minimum entity level, and the reserved dependency information has a dependency information occurring between entities as a minimum dependency level.
8. A multi-lingual extensible code-dependent parsing method according to claim 2, wherein the information format of finer granularity, including the fact that the entity is an object structure having attributes including but not limited to name, code location and type, can have subdivision types in addition to types, reflecting the finer granularity of entity characteristics.
9. A multi-lingual extensible code dependency resolution method in accordance with claim 2 wherein the breadth of dependency categories comprises dynamic dependency and static dependency.
10. The method of claim 2, wherein the sequence of the dependency backfill includes integrating a symbol table, completing the dependency backfill in the order of "Export before Import and other after Export", and the incomplete dependency completing the dependency backfill is complemented into a complete dependency store.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211516728.0A CN116302919A (en) | 2022-11-29 | 2022-11-29 | Multi-language extensible code dependency analysis model and analysis method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211516728.0A CN116302919A (en) | 2022-11-29 | 2022-11-29 | Multi-language extensible code dependency analysis model and analysis method |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116302919A true CN116302919A (en) | 2023-06-23 |
Family
ID=86824563
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211516728.0A Pending CN116302919A (en) | 2022-11-29 | 2022-11-29 | Multi-language extensible code dependency analysis model and analysis method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116302919A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116955719A (en) * | 2023-09-20 | 2023-10-27 | 布谷云软件技术(南京)有限公司 | Code management method and system for digital storage of chained network structure |
-
2022
- 2022-11-29 CN CN202211516728.0A patent/CN116302919A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116955719A (en) * | 2023-09-20 | 2023-10-27 | 布谷云软件技术(南京)有限公司 | Code management method and system for digital storage of chained network structure |
| CN116955719B (en) * | 2023-09-20 | 2023-12-05 | 布谷云软件技术(南京)有限公司 | Code management method and system for digital storage of chained network structure |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN103412853B (en) | A kind of automatic example generation method for file convertor | |
| JP7172435B2 (en) | Representation of software using abstract code graphs | |
| CN102567201B (en) | Method for automatically recovering cross-model GUI (graphic user interface) test scripts | |
| CN110825385B (en) | Method for constructing read Native offline package and storage medium | |
| CN102880468A (en) | Code intelligent prompting method and system for electronic control unit (ECU) program development | |
| CN113901083B (en) | Heterogeneous data source operation resource analysis positioning method and equipment based on multiple resolvers | |
| CN112256271B (en) | Block chain intelligent contract safety detection system based on static analysis | |
| US11262988B2 (en) | Method and system for using subroutine graphs for formal language processing | |
| CN116302919A (en) | Multi-language extensible code dependency analysis model and analysis method | |
| CN104899037A (en) | Intrusive type grey box assembly validation method based on model | |
| CN116560642A (en) | Code generation method and device, electronic equipment and storage medium | |
| CN103235757B (en) | Several apparatus and method that input domain tested object is tested are made based on robotization | |
| CN112395198B (en) | Software defect discovery method based on differential subgraph mining | |
| US20090064092A1 (en) | Visual programming language optimization | |
| CN111488276A (en) | Software reliability testing method and device based on code tracking | |
| CN112115125B (en) | Database access object name resolution method and device and electronic equipment | |
| Creager et al. | Stack graphs: Name resolution at scale | |
| CN109710538B (en) | Static detection method for state-related defects in large-scale system | |
| CN101126983A (en) | Structural model merge method and system | |
| Grigorev et al. | String-embedded language support in integrated development environment | |
| CN102129406A (en) | Condition value-based software static forecasting method and tool | |
| CN117909121A (en) | Deadlock repair system, method and computer device | |
| CN114968806A (en) | Method, device, equipment and medium for generating unit test case | |
| CN115964289A (en) | Python-based SDK interface and function testing method, device, equipment and medium | |
| Lammich | Lock sensitive analysis of parallel programs |
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 |