CN113849392A - Method and device for analyzing function call - Google Patents
Method and device for analyzing function call Download PDFInfo
- Publication number
- CN113849392A CN113849392A CN202010596941.1A CN202010596941A CN113849392A CN 113849392 A CN113849392 A CN 113849392A CN 202010596941 A CN202010596941 A CN 202010596941A CN 113849392 A CN113849392 A CN 113849392A
- Authority
- CN
- China
- Prior art keywords
- node
- calling
- class
- called
- function
- 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
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/3616—Software analysis for verifying properties of programs using software metrics
-
- 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/77—Software metrics
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method and a device for analyzing function call, and relates to the technical field of computer software. The method comprises the following steps: traversing the source code of the function in the project, and extracting the packet node, the class node, the method node and the method call relation in the source code; according to the method calling relation, carrying out hierarchical division on the packet nodes of the class where the method nodes are located; and through a method calling line, the calling method node points to the called method node to obtain a calling relation structure chart of the function. According to the method and the system, the function calling structure of the whole project is analyzed to obtain the function calling relation with the hierarchical structure, so that developers can clearly know the whole function calling structure of the project, and the efficiency of project analysis, development and maintenance is improved.
Description
Technical Field
The present disclosure relates to the field of computer software technologies, and in particular, to a method and an apparatus for analyzing function calls.
Background
The source code analysis is a work which can not be avoided by software developers no matter research the source opening project, secondary development or framework change. However, for more complex items, it is difficult to easily understand the overall hierarchical structure and function call structure of the items.
Most algorithms and tools for source code analysis are used for analyzing all function calls of a certain method or converting a certain method into a flow chart in a more detailed level, and the analysis method is difficult to know the whole function call structure of a project.
Disclosure of Invention
One technical problem to be solved by the present disclosure is to provide a method and an apparatus for analyzing function calls, which can improve the efficiency of project analysis, development and maintenance.
According to an aspect of the present disclosure, a method for analyzing a function call is provided, including: traversing the source code of the function in the project, and extracting the packet node, the class node, the method node and the method call relation in the source code; according to the method calling relation, carrying out hierarchical division on the packet nodes of the class where the method nodes are located; and through a method calling line, the calling method node points to the called method node to obtain a calling relation structure chart of the function.
In some embodiments, according to the calling relationship structure diagram, the calling complexity of the current method node is determined according to the number of method calling lines from the current method node to a leaf node or a root node.
In some embodiments, hierarchically partitioning the packet nodes of the class in which the method node is located includes: if the method node is an entry method node, taking a packet node of the class where the entry method node is located as a first level; and if the method node is the called node, determining that the hierarchy of the package node of the class where the called node is located is the next hierarchy of the corresponding hierarchy of the package node of the class where the method node calling the called node is located.
In some embodiments, if the called node is called by a plurality of levels of method nodes, the lowest level corresponding to the package node of the class where the called node is located in the plurality of levels of method nodes is determined, and the level of the package node of the class where the called node is located is determined to be the next level below the lowest level.
In some embodiments, a first mapping relation is established, wherein the first mapping relation takes a package node name as a key and takes a class node object list contained in the package node name as a value; establishing a second mapping relation with the name of the class node as key and the list of the method node objects contained in the name of the class node as value; and establishing a third mapping relation with the name of the method node as key and the object list of the method node called by the method node as value.
According to another aspect of the present disclosure, there is also provided an apparatus for analyzing a function call, including: the node information extraction module is configured to traverse the source code of the function in the project and extract the packet node, the class node, the method node and the method call relation in the source code; the hierarchical division module is configured to carry out hierarchical division on the package nodes of the class where the method nodes are located according to the method calling relation; and the calling relation structure chart generation module is configured to point the calling method node to the called method node through the method calling line to obtain a calling relation structure chart of the function.
In some embodiments, the complexity labeling module is configured to determine the calling complexity of the current method node according to the number of method calling lines from the current method node to a leaf node or a root node according to the calling relationship structure diagram.
In some embodiments, the hierarchical partitioning module is configured to, if the method node is an ingress method node, take the packet node of the class in which the ingress method node is located as the first hierarchy; and if the method node is the called node, determining that the hierarchy of the package node of the class where the called node is located is the next hierarchy of the corresponding hierarchy of the package node of the class where the method node calling the called node is located.
According to another aspect of the present disclosure, there is also provided an apparatus for analyzing a function call, including: a memory; and a processor coupled to the memory, the processor configured to perform the method of analyzing function calls as described above based on instructions stored in the memory.
According to another aspect of the present disclosure, a non-transitory computer-readable storage medium is also presented, having stored thereon computer program instructions, which when executed by a processor, implement the above-described method of analyzing function calls.
In the embodiment of the disclosure, the function call structure of the whole project is analyzed to obtain the function call relation with the hierarchical structure, so that developers can clearly know the whole function call structure of the project, and the efficiency of project analysis, development and maintenance is improved.
Other features of the present disclosure and advantages thereof will become apparent from the following detailed description of exemplary embodiments thereof, which proceeds with reference to the accompanying drawings.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the disclosure and together with the description, serve to explain the principles of the disclosure.
The present disclosure may be more clearly understood from the following detailed description, taken with reference to the accompanying drawings, in which:
fig. 1 is a flow diagram of some embodiments of a method of analyzing function calls of the present disclosure.
FIG. 2 is a diagram of a call relationship structure of functions in some embodiments of the present disclosure.
FIG. 3 is a flow diagram illustrating further embodiments of the disclosed method of analyzing function calls.
Fig. 4 is a block diagram of some embodiments of an apparatus for analyzing function calls according to the present disclosure.
Fig. 5 is a schematic structural diagram of an apparatus for analyzing function calls according to another embodiment of the present disclosure.
Fig. 6 is a schematic structural diagram of an apparatus for analyzing function calls according to another embodiment of the present disclosure.
Detailed Description
Various exemplary embodiments of the present disclosure will now be described in detail with reference to the accompanying drawings. It should be noted that: the relative arrangement of the components and steps, the numerical expressions, and numerical values set forth in these embodiments do not limit the scope of the present disclosure unless specifically stated otherwise.
Meanwhile, it should be understood that the sizes of the respective portions shown in the drawings are not drawn in an actual proportional relationship for the convenience of description.
The following description of at least one exemplary embodiment is merely illustrative in nature and is in no way intended to limit the disclosure, its application, or uses.
Techniques, methods, and apparatus known to those of ordinary skill in the relevant art may not be discussed in detail but are intended to be part of the specification where appropriate.
In all examples shown and discussed herein, any particular value should be construed as merely illustrative, and not limiting. Thus, other examples of the exemplary embodiments may have different values.
It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, further discussion thereof is not required in subsequent figures.
For the purpose of promoting a better understanding of the objects, aspects and advantages of the present disclosure, reference is made to the following detailed description taken in conjunction with the accompanying drawings.
Fig. 1 is a flow diagram of some embodiments of a method of analyzing function calls of the present disclosure.
In step 110, the source code of the function in the project is traversed, and the package node, the class node, the method node and the method calling relation in the source code are extracted.
In this embodiment, the function is, for example, a custom function. When the source code analysis is carried out, a developer needs to be better aware of the calling of the custom function of the project. For the calling of the self-carried functions of the known library or jdk (software development kit of Java language), the source code does not need to be analyzed generally, the function can be known basically by searching or looking for official documents on the network, and the function with the self-defined function needs to be analyzed by the source code. Therefore, the analysis only aiming at the calling relation of the self-defined function is more in line with the analysis requirement of the source code.
In some embodiments, the packet node comprises a class node, the class node comprises a method node, and the method node comprises method node information called by the method node.
In step 120, according to the method calling relationship, the package node of the class where the method node is located is hierarchically divided.
For example, if the method node is an entry method node, the packet node of the class where the entry method node is located is taken as a first hierarchy; and if the method node is the called node, determining the hierarchy of the package node of the class where the called node is located as the next hierarchy of the corresponding hierarchy of the package node of the class where the method node calling the called node is located.
In step 130, the calling method node is pointed to the called method node through the method calling line, and a calling relation structure diagram of the function is obtained.
For example, as shown in FIG. 2, a method node of a first hierarchy calls a method node of a second hierarchy.
In the embodiment, the self-defined function calling relationship with the hierarchical structure is obtained by analyzing the function calling structure of the whole project, so that developers can clearly know the whole function calling structure of the project, and the efficiency of project analysis, development and maintenance is improved.
FIG. 3 is a flow diagram illustrating further embodiments of the disclosed method of analyzing function calls.
In step 310, the source code of the custom function in the project is traversed, and the package node, the class node, the method node and the method calling relation in the source code are extracted.
At step 320, a mapping relationship is established between the package node, the class node, the method node, and the called method node.
In some embodiments, a first mapping relation is established, wherein the package node name is a key, and a class node object list contained by the package node name is a value; establishing a second mapping relation with the name of the class node as key and the list of the method node objects contained in the name of the class node as value; and establishing a third mapping relation with the name of the method node as key and the object list of the method node called by the method node as value. Through the mapping relation, the calling relation structure of the user-defined function is convenient to establish.
In step 330, the packet node of the class where the entry method node is located is taken as a first hierarchy, the packet node of the class where the method node called by the method node in the class node of the first hierarchy is taken as a second hierarchy, and so on, the custom function calling relation forest with the packet as the hierarchy, the class as a module, and the custom method as the minimum unit node and having the hierarchical structure is obtained. And calling the relation forest, namely calling the relation structure chart.
In some embodiments, the code is executed by one or more entry methods, such as a general java project entering main function and a web project entering api method. Therefore, in this embodiment, the packet node in the class of the entry method node is the first hierarchy, and the first hierarchy is the highest hierarchy. The method call line is directed by the method node to the called method node.
In some embodiments, if the called node is called by a plurality of levels of method nodes, the lowest level corresponding to the package node of the class where the called node is located in the plurality of levels of method nodes is determined, and the level of the package node of the class where the called node is located is determined to be the next level below the lowest level.
For example, if the called node is called by both the method node of the first hierarchy and the method node of the third hierarchy, the level of the packet node in the class of the called node is the fourth hierarchy.
In step 340, according to the calling relationship structure diagram, the calling complexity of the current method node is determined according to the number of method calling lines from the current method node to the leaf node or the root node.
The judgment of the method calling complexity is mainly embodied in that the total calling line number sum of a certain method node is marked in the forward direction, or the calling node complexity is calculated by the called node complexity in the reverse direction. For example, if the complexity is labeled in the forward direction, the complexity is the sum Σ i of the number i of all call lines from the node to the leaf node. If the leaf node is used for reversely marking the complexity, the leaf node complexity is 0, and the child node complexity is defined as alpha, the parent node complexity beta is ═ sigma (alpha + 1).
For example, as shown in FIG. 2, the calling complexity of method node D and method node E is 0, the calling complexity of method node C is 1, the calling complexity of method node B is 2, and the calling complexity of method node A is 5.
In the embodiment, the function call structure diagram with the hierarchical structure is analyzed according to the source code, and then the method for calculating the self-defined method call complexity in the project is calculated. By checking the method complexity of the whole project, whether the business process related to the project is complex or not can be evaluated. And can also be used as a standard for code auditing of code from another perspective.
Fig. 4 is a block diagram of some embodiments of an apparatus for analyzing function calls according to the present disclosure. The apparatus includes a node information extraction module 410, a hierarchy division module 420, and a call relation structure diagram generation module 430.
The node information extraction module 410 is configured to traverse the source code of the functions in the project, extracting the package nodes, class nodes, method nodes, and method call relationships in the source code.
In some embodiments, the function is a custom function. And extracting package nodes, a class node list contained in each package node, a method node list contained in each class node and called method node list information contained in each method node according to the source code of the custom function.
In some embodiments, a first mapping relation is established, wherein the package node name is used as a key, and a class node object list contained by the package node name is used as a value; establishing a second mapping relation with the name of the class node as key and the list of the method node objects contained in the name of the class node as value; and establishing a third mapping relation with the name of the method node as key and the object list of the method node called by the method node as value. Through the mapping relation, the calling relation structure of the user-defined function is convenient to establish.
The hierarchical division module 420 is configured to perform hierarchical division on the package nodes of the class where the method nodes are located according to the method calling relationship.
In some embodiments, the hierarchical partitioning module 420 is configured to, if the method node is an ingress method node, take the packet node of the class in which the ingress method node is located as the first hierarchy; and if the method node is the called node, determining that the hierarchy of the package node of the class where the called node is located is the next hierarchy of the corresponding hierarchy of the package node of the class where the method node calling the called node is located.
For example, a packet node of a class where an entry method node is located is taken as a first hierarchy, a packet node of a class where a method node called by the method node in the class node of the first hierarchy is taken as a second hierarchy, and so on, to obtain a custom function calling relation forest which takes the packet as the hierarchy, the class as a module, and the custom method as the minimum unit node and has a hierarchical structure.
In some embodiments, if the called node is called by a plurality of levels of method nodes, the lowest level corresponding to the package node of the class where the called node is located in the plurality of levels of method nodes is determined, and the level of the package node of the class where the called node is located is determined to be the next level below the lowest level.
The calling relationship structure diagram generating module 430 is configured to point the calling method node to the called method node through the method calling line, so as to obtain a calling relationship structure diagram of the function.
In the embodiment, the self-defined function calling relationship with the hierarchical structure is obtained by analyzing the function calling structure of the whole project, so that developers can clearly know the whole function calling structure of the project, and the efficiency of project analysis, development and maintenance is improved.
In other embodiments of the present disclosure, as shown in fig. 5, the apparatus further includes a complexity labeling module 510 configured to determine the calling complexity of the current method node according to the number of method calling lines from the current method node to a leaf node or a root node according to the calling relationship structure diagram.
In the embodiment, through the complexity analysis of the method node, a developer can be helped to clearly and quickly locate the method node with higher function call complexity and the class with unobvious hierarchical structure, so that the optimization is carried out, and the quality of the project code is improved.
Fig. 6 is a schematic structural diagram of an apparatus for analyzing function calls according to another embodiment of the present disclosure. The apparatus includes a memory 610 and a processor 620. Wherein: the memory 610 may be a magnetic disk, flash memory, or any other non-volatile storage medium. The memory is used for storing instructions in the embodiments corresponding to fig. 1 and 3. Processor 620 is coupled to memory 610 and may be implemented as one or more integrated circuits, such as a microprocessor or microcontroller. The processor 620 is configured to execute instructions stored in the memory.
In some embodiments, processor 620 is coupled to memory 610 through a BUS BUS 630. The apparatus 600 may also be coupled to an external storage system 650 via a storage interface 640 for external data retrieval, and may also be coupled to a network or another computer system (not shown) via a network interface 660. And will not be described in detail herein.
In the embodiment, the data instructions are stored in the memory and processed by the processor, so that the efficiency of project analysis, development and maintenance is improved.
In further embodiments, a computer-readable storage medium has stored thereon computer program instructions which, when executed by a processor, implement the steps of the method in the embodiments corresponding to fig. 1 and 3. As will be appreciated by one skilled in the art, embodiments of the present disclosure may be provided as a method, apparatus, or computer program product. Accordingly, the present disclosure may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present disclosure may take the form of a computer program product embodied on one or more computer-usable non-transitory 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 disclosure is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the disclosure. 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 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.
Thus far, the present disclosure has been described in detail. Some details that are well known in the art have not been described in order to avoid obscuring the concepts of the present disclosure. It will be fully apparent to those skilled in the art from the foregoing description how to practice the presently disclosed embodiments.
Although some specific embodiments of the present disclosure have been described in detail by way of example, it should be understood by those skilled in the art that the foregoing examples are for purposes of illustration only and are not intended to limit the scope of the present disclosure. It will be appreciated by those skilled in the art that modifications may be made to the above embodiments without departing from the scope and spirit of the present disclosure. The scope of the present disclosure is defined by the appended claims.
Claims (10)
1. A method of analyzing function calls, comprising:
traversing a source code of a function in a project, and extracting a packet node, a class node, a method node and a method call relation in the source code;
according to the method calling relationship, carrying out hierarchical division on the packet nodes of the class where the method nodes are located; and
and through a method calling line, the calling method node points to the called method node to obtain a calling relation structure chart of the function.
2. The method of claim 1, further comprising:
and determining the calling complexity of the current method node according to the calling relationship structure chart and the number of method calling lines from the current method node to leaf nodes or root nodes.
3. The method of claim 1, wherein hierarchically partitioning the packet nodes of the class in which the method nodes are located comprises:
if the method node is an entry method node, taking a packet node of the class where the entry method node is located as a first level; and
and if the method node is the called node, determining the hierarchy of the package node of the class where the called node is located as the next hierarchy of the hierarchy corresponding to the package node of the class where the method node calling the called node is located.
4. The method of claim 3, wherein,
if the called node is called by the method nodes of the multiple levels, determining the lowest level corresponding to the package node of the class where the called node is located in the method nodes of the multiple levels, and determining the level of the package node of the class where the called node is located as the next level below the lowest level.
5. The method of any of claims 1 to 4, further comprising:
establishing a first mapping relation with a package node name as a key and a class node object list contained in the package node name as a value;
establishing a second mapping relation with a class node name as a key and a method node object list contained in the class node name as a value; and
and establishing a third mapping relation with the name of the method node as key and the object list of the method node called by the method node as value.
6. An apparatus to analyze function calls, comprising:
the node information extraction module is configured to traverse a source code of a function in a project and extract a packet node, a class node, a method node and a method call relation in the source code;
the hierarchical division module is configured to carry out hierarchical division on the package nodes of the class where the method nodes are located according to the method calling relationship; and
and the calling relation structure chart generation module is configured to point the calling method node to the called method node through the method calling line to obtain the calling relation structure chart of the function.
7. The apparatus of claim 6, further comprising:
and the complexity marking module is configured to determine the calling complexity of the current method node according to the calling relationship structure chart and the number of method calling lines from the current method node to a leaf node or a root node.
8. The apparatus of claim 6, wherein,
the hierarchical division module is configured to take a packet node of a class where the entry method node is located as a first hierarchy if the method node is an entry method node; and if the method node is the called node, determining that the hierarchy of the package node of the class where the called node is located is the next hierarchy of the hierarchy corresponding to the package node of the class where the method node calling the called node is located.
9. An apparatus to analyze function calls, comprising:
a memory; and
a processor coupled to the memory, the processor configured to execute the method of analyzing function calls of any of claims 1-5 based on instructions stored in the memory.
10. A non-transitory computer readable storage medium having stored thereon computer program instructions which, when executed by a processor, implement the method of analysing a function call of any of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010596941.1A CN113849392A (en) | 2020-06-28 | 2020-06-28 | Method and device for analyzing function call |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010596941.1A CN113849392A (en) | 2020-06-28 | 2020-06-28 | Method and device for analyzing function call |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113849392A true CN113849392A (en) | 2021-12-28 |
Family
ID=78972527
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010596941.1A Pending CN113849392A (en) | 2020-06-28 | 2020-06-28 | Method and device for analyzing function call |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113849392A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116069667A (en) * | 2023-03-06 | 2023-05-05 | 天津卓朗昆仑云软件技术有限公司 | Test case auxiliary positioning method and device based on code analysis |
-
2020
- 2020-06-28 CN CN202010596941.1A patent/CN113849392A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116069667A (en) * | 2023-03-06 | 2023-05-05 | 天津卓朗昆仑云软件技术有限公司 | Test case auxiliary positioning method and device based on code analysis |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10289541B2 (en) | Source code flow analysis using information retrieval | |
| US9576037B2 (en) | Self-analyzing data processing job to determine data quality issues | |
| CN110502227B (en) | Code complement method and device, storage medium and electronic equipment | |
| EP3623948B1 (en) | Method and system for code analysis to identify causes of code smells | |
| US10394694B2 (en) | Unexplored branch search in hybrid fuzz testing of software binaries | |
| CN106843840B (en) | Source code version evolution annotation multiplexing method based on similarity analysis | |
| CN113641701B (en) | Data query method, system, heterogeneous acceleration platform and storage medium | |
| CN107015839B (en) | Method and device for realizing front-end event agent | |
| US8869125B2 (en) | Systems and methods for demarcating information related to one or more blocks in an application | |
| CN110263104B (en) | JSON character string processing method and device | |
| WO2017128952A1 (en) | Stack protection method and device | |
| CN113760891A (en) | Data table generation method, device, equipment and storage medium | |
| CN111079408A (en) | Language identification method, device, equipment and storage medium | |
| CN110765402A (en) | Visual acquisition system and method based on network resources | |
| Solanki et al. | Comparative study of software clone detection techniques | |
| CN113849392A (en) | Method and device for analyzing function call | |
| CN108897678B (en) | Static code detection method, static code detection system and storage device | |
| CN112434831A (en) | Troubleshooting method and device, storage medium and computer equipment | |
| CN115599388B (en) | API (application program interface) document generation method, storage medium and electronic equipment | |
| JP2016051367A (en) | Data analysis device, data analysis method, and program | |
| CN113778450A (en) | Processing method, device and equipment for dependency conflict and storage medium | |
| KR101673151B1 (en) | Method and Apparatus for Analyzing Relationship Change of Program Source and DB Schema | |
| US20190294534A1 (en) | Program usability performance classification | |
| US11010387B2 (en) | Join operation and interface for wildcards | |
| WO2015145538A1 (en) | Program chart creation device, program chart creation method, and program chart creation program |
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 |