A method and system for dynamically querying CAA component information

Abstract

This invention belongs to the field of computer-aided design secondary development technology, and specifically relates to a method for dynamically querying CAA component information. The method includes: utilizing publicly available information of the target software, obtaining the address of the QueryMetaObject metadata query function through debugging; entering the function body, and within the function body, finding the nearest relative addressing function instruction; entering the corresponding function body, locating the global dictionary through the relative addressing instruction of global variables, parsing the global dictionary according to the hash linked list data structure, and constructing a query tool; inputting query conditions in the query tool interface, traversing the linked list nodes, and completing the CAA component information query. This method has high retrieval performance, richer query fields, and more complete query results, making it suitable for CAA component secondary development scenarios. This invention also provides a non-transitory readable recording medium storing the program of this method and a system containing the medium, which can call the program through processing circuitry to execute the above method.

Description

Technical Field

[0001] This invention belongs to the field of computer-aided design secondary development technology, and discloses a method, recording medium and system for dynamically querying CAA component information. Background Technology

[0002] Dassault Systèmes' 3DEXPERIENCE (3DE) platform is a mainstream integrated 3D design and Building Information Modeling (BIM) application platform in the current industrial field. It integrates collaborative design, analysis and calculation, construction simulation, and business intelligence capabilities across the entire process. Widely used in high-end manufacturing and engineering construction industries, it has become a typical foundation for large-scale industrial software and digital R&D systems. The 3DE platform's secondary development system is centered on Component Application Architecture (CAA), adopting a programming paradigm oriented towards executable components. It supports binary-level reuse and modular development, possessing high robustness and scalability, making it the mainstream technical route for large-scale industrial software development. As a deep abstraction of object-oriented thinking, CAA components adhere to strict interface specifications and architectural constraints. Developers need to accurately grasp component creation, interface binding, and runtime calling logic. During development, it is often necessary to determine object pointer ownership, query derivation relationships, and enumerate supporting interfaces and metadata information to ensure the correctness of business logic and development efficiency.

[0003] To support CAA secondary development, Dassault Systèmes provides a Rapid Application Development Environment (RADE) suite. Its native component lookup tool relies on static configuration files in a specified directory of the platform client to retrieve components and interfaces. The relevant files include text dictionary files in .iid, .dic, and .dico formats, as well as the Bindict binary configuration file, which can provide developers with basic information query capabilities such as component names, interface affiliation, and framework and module associations. However, this official query mechanism relies on static dictionary files, which has significant technical limitations: First, the query efficiency is low, requiring the loading and parsing of a large number of scattered small files for the first query, resulting in high file read / write I / O (Input / Output) overhead and slow response; Second, the query dimensions are limited, supporting only basic name-based searches and failing to meet the needs for deep meta-information queries such as derivation relationships, interface implementations, and inheritance chains; Third, the reliability of the results is insufficient, with query accuracy entirely dependent on the completeness and correctness of the configuration file, which is prone to missing configurations, version mismatches, or description errors, leading to distorted query results; Fourth, the runtime adaptability is poor, unable to link with the runtime component instance state, making it difficult to support dynamic debugging and real-time verification scenarios.

[0004] The aforementioned shortcomings significantly increase the debugging cost and error probability of CAA secondary development. Developers are prone to problems such as interface call failures, type conversion anomalies, and component dependency errors due to inaccurate or incomplete information, seriously affecting development progress and system stability. Therefore, for the CAA architecture of the 3DE platform, there is an urgent need for a technical solution that can break away from static dictionary dependencies, directly parse component kernel metadata, and support runtime dynamic queries to compensate for the shortcomings of existing tools in terms of efficiency, dimensionality, reliability, and dynamism, and improve the quality and efficiency of CAA secondary development. Summary of the Invention

[0005] To address the above problems, this invention provides a method for dynamically querying CAA component information, comprising the following steps:

[0006] S1. Utilize publicly available information from the target software to obtain the address of the QueryMetaObject function through debugging and location;

[0007] S2. Analyze the code containing the QueryMetaObject function, retrieve the function that is closest to the relative address; enter the corresponding function body, find the relative address of the global variable, locate and obtain the global dictionary, parse the global dictionary according to the hash linked list data structure, and use this structure as the query architecture to build the queryer;

[0008] S3. Enter the query conditions in the query interface, traverse the hash chain, obtain the current head node of the chain through the bucket index; traverse the current chain, parse the chain node object information, and complete the CAA component information query.

[0009] Preferably, the instructions for retrieving the function call that is relatively closest to the address include the sequentially executed `call func` and `test rax,rax` assembly instructions.

[0010] Preferably, the instruction for finding the relative address of a global variable is the lea r10, rel32 assembly instruction.

[0011] Preferably, the member fields of the linked list node object are constructed from the module name, framework name, dependent framework name, component name, main class name of the component, extended class name of the component, dynamically created symbol, address of the dynamically created function, and status option dependency relationship.

[0012] This allows for direct retrieval using the combined hash value of the component's main class name and extended class name.

[0013] Preferably, the status options include extended type, class definition type, and authorization status.

[0014] Another aspect of the present invention is to provide a non-transient readable recording medium for storing one or more programs containing multiple instructions, which, when executed, cause the processing circuit to perform the above-described method for dynamically querying CAA component information.

[0015] Another aspect of the present invention provides a system for dynamically querying CAA component information, including a processing circuit and a memory electrically coupled thereto, the memory being configured to store at least one program, the program containing multiple instructions, the processing circuit running the program, and capable of executing the aforementioned method for dynamically querying CAA component information.

[0016] Compared with existing technologies, the method, recording medium, and system for dynamically querying CAA component information provided by this invention can bring the following beneficial effects:

[0017] ① The query performance is more efficient. It can directly read existing data in memory for querying without loading configuration files, and can achieve millisecond-level querying; while the native component queryer takes minutes from loading to querying.

[0018] ② The query fields are richer, providing more than ten types of member field information and offering more query options.

[0019] ③ The query results are more complete, and component information can be queried even if there is no corresponding dictionary configuration file. Attached Figure Description

[0020] Figure 1 This is the interface for Dassault's native component query tool;

[0021] Figure 2 This is the query interface in an embodiment of the present invention;

[0022] Figure 3 This is a schematic diagram of the overall workflow in an embodiment of the present invention;

[0023] Figure 4 This is a schematic diagram of the component dictionary hash operation process in an embodiment of the present invention. Detailed Implementation

[0024] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be described below with reference to the accompanying drawings. The described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without innovative effort are within the scope of protection of the present invention.

[0025] A specific embodiment of a method for dynamically querying CAA component information is as follows:

[0026] 1. Locate the global dictionary in memory.

[0027] 1.1 Obtain the base address of the JS0GROUP module;

[0028] 1.2 Obtain the address of the exported symbol QueryMetaObject(char const*) function as the disassembly entry point;

[0029] 1.3 Search for the assembly instruction `call func+test rax, rax` to enter the function body containing the closest relative addressing call;

[0030] 1.4 Search for the assembly instructions lea r10, rel32, and parse the relative addresses to obtain the global dictionary pointer location;

[0031] 2. Determine the detailed information of the global dictionary data structure.

[0032] 2.1 The global dictionary data structure is a hash table with a bucket size of 0x5000, and hash collisions are handled using chaining.

[0033] 2.2 Hash function algorithm as follows Figure 4 As shown, the algorithm input is the main class name of the component and the extended keyword, the hash seed value is 0x25, and the hash value is the bucket index;

[0034] 2.3 The hash bucket stores objects as linked lists, and the linked list data field is a pointer to a specific dictionary object. The object size is 0x60.

[0035] 3. Use a double loop to traverse the query and provide query services based on the input conditions.

[0036] 3.1 Traverse the hash table and obtain the current head node of the linked list using the bucket index;

[0037] ① At offset 0x00, dereference the data field to obtain the dictionary object, and then perform parsing and querying;

[0038] ② Offset 0x08, dereference the pointer field to the next node, and proceed to the next round;

[0039] ③ If the data field or pointer field is empty, the current linked list traversal ends;

[0040] 3.2 Traverse the current linked list, where the node data field is a pointer to a dictionary object, and parse the member fields;

[0041] Offset 0x0 bytes serves as a unique identifier for the component.

[0042] Offset of 0x8 bytes is used for extended unique identification;

[0043] Offset 0x10 bytes represents the main class name of the component;

[0044] Offset 0x18 bytes is for extended keyword names, such as interface, metadata, factory, etc.

[0045] Offset 0x20 bytes represents the module name;

[0046] Offset 0x28 bytes is used for dynamically creating symbol names;

[0047] Offset 0x38 bytes represents the name of the frame.

[0048] Offset 0x40 bytes represents the name of the license dependency framework;

[0049] Offset 0x48 bytes is for dynamically created function addresses or dictionary metadata pointers;

[0050] Offset 0x58 bytes is for identifying options such as extended type, class definition type, and authorization status.

[0051] 3.3 Provide query services based on query conditions, including:

[0052] For precise queries, enter the class name, extended keyword name, module name, or framework name to perform an exact match query;

[0053] Fuzzy search: Enter the query text and query options, such as hash value or attribute name, to perform a fuzzy matching query.

[0054] Assembling the above methods and steps into a program and storing it on a hard disk or other non-transitory storage medium constitutes an embodiment of the present invention's "a non-transitory readable recording medium"; while electrically connecting the storage medium to a computer processor and enabling dynamic querying of CAA component information through data processing constitutes an embodiment of the present invention's "a system for dynamically querying CAA component information".

[0055] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computers or available storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0056] This 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 block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can 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, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0057] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0058] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0059] Finally, it should be noted that the above descriptions are merely preferred embodiments of the present invention and are not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for dynamically querying CAA component information, characterized in that, Includes the following steps: S1. Utilize publicly available information from the target software to obtain the address of the QueryMetaObject function through debugging and location; S2. Analyze the code containing the QueryMetaObject function, retrieve the function that is closest to the relative address; enter the corresponding function body, find the relative address of the global variable, locate and obtain the global dictionary, parse the global dictionary according to the hash linked list data structure, and use this structure as the query architecture to build the queryer; S3. Enter the query conditions in the query interface, traverse the hash chain, obtain the current head node of the chain through the bucket index; traverse the current chain, parse the chain node object information, and complete the CAA component information query.

2. The method for dynamically querying CAA component information according to claim 1, characterized in that, Instructions that retrieve the function call closest to the relative address include the sequentially executed `call func` and `test rax, rax` assembly instructions.

3. The method for dynamically querying CAA component information according to claim 2, characterized in that, The instruction for finding the relative address of a global variable is the lea r10, rel32 assembly instruction.

4. The method for dynamically querying CAA component information according to claim 3, characterized in that, The member fields of the linked list node object are constructed from the module name, framework name, dependent framework name, component name, main class name of the component, extended class name of the component, dynamically created symbol, address of the dynamically created function, and status options and their hierarchical relationships.

5. The method for dynamically querying CAA component information according to claim 4, characterized in that, Status options include extended type, class definition type, and authorization status.

6. A non-transitory readable recording medium for storing one or more programs containing multiple instructions, characterized in that, When the instruction is executed, the processing circuit will perform a method for dynamically querying CAA component information as described in any one of claims 1-5.

7. A system for dynamically querying CAA component information, comprising processing circuitry and a memory electrically coupled thereto, characterized in that, The memory is configured to store at least one program, the program containing multiple instructions, and the processing circuit runs the program to execute a method for dynamically querying CAA component information according to any one of claims 1-5.

Images