Methods for constructing third-party libraries, methods for verifying the legality of third-party libraries, methods for calling multiple third-party libraries from each other, and calling devices.

Abstract

To construct a third-party library.SOLUTION: A method for constructing multiple third-party libraries in a software-platform-specific mutual calling method for functions of third-party libraries includes constructing at least one third-party library by a software platform, i.e., constructing an initializing sub module, a performance obtaining sub module and an internal sub module in the third-party library by the software platform.SELECTED DRAWING: Figure 2

Description

Technical Field

[0005] , , , ,

[0006] ,

[0001] The present invention belongs to the field of computer technology, and specifically relates to a method for constructing a third-party library, a method for verifying the legality of a third-party library, a method for mutual calling of multiple third-party libraries, and a calling device.

Background Art

[0002] The software platform based on Windows performs function expansion by introducing a third-party library. There is a situation where one third-party library calls another third-party library in the third-party library introduced into the software platform. The conventional method realizes the call to another third-party library by modifying the current third-party library and implicitly or explicitly adding another third-party library.

[0003] The problem with the conventional technical solution is that it supports the call to another third-party library by modifying the current third-party library, and it is necessary to increase the workload of the current third-party library. Along with the change of another third-party library, the current third-party library is also changed synchronously. When the current third-party library calls another third-party library by explicitly loading another third-party library, if another third-party library does not exist, the current third-party library cannot be loaded either.

[0004] Therefore, based on the above technical problems, it is necessary to design a method for constructing a third-party library, a method for verifying the legality of a third-party library, a method for mutual calling of multiple third-party libraries, and a calling device.

Summary of the Invention

[0005] The object of the present invention is to provide a method for constructing a third-party library, a method for verifying the legality of a third-party library, a method for mutual calling of multiple third-party libraries, and a calling device.

[0006] To solve the above technical problems, the present invention provides a method for calling third-party library functions for a software platform, which includes: To build multiple third-party libraries To verify the legality of the above-mentioned third-party library, and, The above-mentioned third-party libraries make calls to each other.

[0007] Furthermore, the methods for building the above-mentioned multiple third-party libraries include the following: The software platform constructs each of the above third-party libraries, that is, the software platform constructs the initialization submodule, capability acquisition submodule and internal submodule in each of the above third-party libraries, and constructs the release submodule in the above third-party libraries. The above release submodule is suitable for automatically releasing the requested resources when the above third-party library is unloaded.

[0008] Furthermore, the methods for constructing the above initialization submodule using the above software platform include the following: The above-mentioned initialization submodule is generated using the header files and API list of the above-mentioned software platform within the above-mentioned software platform. After the call to the above-mentioned initialization submodule is completed, the above-mentioned third-party library obtains the address information of each API in the API list provided by the above-mentioned software platform.

[0009] Furthermore, the methods for building capability acquisition submodules using the above software platform include the following: The software platform loads the version number of the software platform, loads a list of corresponding user logical callback submodules, and loads a list of external submodules on which the corresponding third-party library depends, thereby generating the capability acquisition submodule. When an external program calls the capability acquisition submodule, it obtains the version information of the software platform corresponding to the third-party library, the list information of the user logical callback submodules, the information of the external submodules on which the third-party library depends, and all the internal submodule information of the third-party library.

[0010] Furthermore, the methods for building internal submodules using the above software platform include the following: The above internal submodule is generated based on the user function logical submodule of the above software platform.

[0011] Furthermore, methods for verifying the legality of the above-mentioned third-party libraries include the following: The software platform loads the third-party library into the software platform. The software platform calls the initialization submodule of the third-party library. The software platform calls the capability acquisition submodule of the third-party library, obtains the version number of the software platform corresponding to the third-party library, obtains a list of user callback submodules, and obtains address information and function parameter information for all of the internal submodules of the third-party library, as well as information on the external submodules on which the third-party library depends. The software platform provides the third-party library with pointers to the submodules on which it depends. If the external submodule on which the above-mentioned third-party library depends does not exist, the software platform provides the third-party library with a null pointer. The above-mentioned third-party library determines, during the calling process, whether or not there are other third-party libraries on which it depends, based on whether or not it is a null pointer. If it is a null pointer, the internal submodules of other third-party libraries on which the third-party library depends will not be valid, but the functionality of the other internal submodules in the third-party library will still be valid. The software platform compares the version number of the software platform corresponding to the acquired third-party library with its own version number. If the version number of the third-party library is greater than its own version number, it stops calling the third-party library; otherwise, it continues calling the third-party library.

[0012] Furthermore, the methods for calling the above-mentioned third-party libraries from each other include the following: The above software platform is suitable for calling the above third-party library repeatedly, and then calling the above third-party library based on the list of user callback submodules and the list of internal submodules obtained from the above third-party library. If the current third-party library needs to call an internal submodule of another third-party library while it is running, the current third-party library will call the internal submodule in the other third-party library by passing a submodule pointer to the submodule on which the current third-party library depends to the current third-party library via the software platform in the capability acquisition submodule. After the call is complete, the software platform releases the requested resources by calling the release submodule in the third-party library.

[0013] In a second aspect, the present invention further provides a software platform for a method of calling third-party library functions for the above-mentioned software platform, which includes: The header files of the above software platform, the list of APIs for the above software platform, the version number of the above software platform, the list of user logical callback submodules, the list of external submodules on which third-party libraries depend, the user function logical submodules, and the C++ compiler.

[0014] In a third aspect, the present invention further provides a third-party library for a method of calling third-party library functions for the above-mentioned software platform, which includes: The above initialization submodule, the above capability acquisition submodule, the above internal submodule, and the above release submodule.

[0015] In a fourth aspect, the present invention further provides a call system using a method for calling third-party library functions for the above-mentioned software platform, which includes: A construction module that constructs the above-mentioned multiple third-party libraries. A verification module that verifies the legality of the above-mentioned third-party library, and, The calling module and the multiple third-party libraries mentioned above make calls to each other.

[0016] The effects of the present invention are as follows: The present invention realizes a single general-purpose call frame via a software platform by constructing multiple third-party libraries, verifying the legality of the third-party libraries, and enabling the multiple third-party libraries to call each other, and functions registered by the third-party library on the software platform can be shared among all loaded third-party libraries. Thus, if a third-party library needs to call another third-party library, it does not need to load the other third-party library, and access to the other third-party library can be achieved by using a function table shared with the current third-party library that includes the other third-party library on the software platform. If no other third-party library is loaded, both the software platform and the current third-party library can be aware of this situation, thereby smoothly loading the current third-party library and providing some of its functions.

[0017] Other features and advantages of the present invention are described in the following specification and some will become apparent from the specification or will be understood by practicing the invention. The object and other advantages of the present invention are realized and obtained by the structures specifically pointed out in the specification and drawings.

[0018] To make the above-mentioned objectives, features, and advantages of the present invention easier to understand, preferred embodiments will be given below and described in detail in conjunction with the accompanying drawings. [Brief explanation of the drawing]

[0019] To more clearly illustrate specific embodiments of the present invention or technical solutions in the prior art, the drawings that may be used in the description of specific embodiments or prior art are briefly described below. The drawings in the following description are some embodiments of the present invention, and it will be obvious to those skilled in the art that other drawings can be obtained from these drawings without any creative effort. [Figure 1]Figure 1 is a flowchart of a method for mutual calling of third-party library functions for a software platform according to the present invention. [Figure 2] Figure 2 is a flowchart of constructing a plurality of third-party libraries according to the present invention. [Figure 3] Figure 3 is a flowchart of mutual calling among a plurality of third-party libraries according to the present invention. [Figure 4] Figure 4 is a principle block diagram of a mutual calling system designed by the present invention.

Embodiment for Implementing the Invention

[0020] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the following will clearly and completely describe the technical solution of the present invention with reference to the drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments in the present invention, all other embodiments obtained by those skilled in the art without creative labor belong to the protection scope of the present invention.

[0021] Embodiment 1 Figure 1 is a flowchart of a method for mutual calling of third-party library functions for a software platform according to the present invention. As shown in Figure 1, this embodiment 1 provides a method for mutually calling third-party library functions for a software platform, which includes: constructing multiple third-party libraries, verifying the legitimacy of the third-party libraries, and enabling a single general-purpose call frame via the software platform through mutual calls between the multiple third-party libraries, so that functions registered by the third-party library to the software platform can be shared among all loaded third-party libraries. Thus, when the current third-party library needs to call another third-party library, it does not need to load the other third-party library, and access to the other third-party library can be achieved by using a function table shared with the current third-party library that includes the other third-party library. If no other third-party library is loaded, both the software platform and the current third-party library can be aware of this situation, thereby smoothly loading the current third-party library and providing some functionality.

[0022] Figure 2 is a flowchart for constructing multiple third-party libraries according to the present invention. As shown in Figure 2, in this embodiment, the method for constructing the above-mentioned multiple third-party libraries is as follows: The software platform calls a C++ compiler to construct the third-party libraries. The software platform constructs each third-party library, that is, the software platform constructs an initialization submodule (including initialization functions and corresponding functions), a capability acquisition submodule (including capability acquisition functions and corresponding functions), and an internal submodule (including internal functions and corresponding functions) in each third-party library, and constructs a release submodule (including release functions and corresponding functions) in the third-party library. The release submodule is suitable for automatically releasing the requested resources when the third-party library is unloaded. The initialization submodule, capability acquisition submodule, and release submodule are disclosed submodules, and functions in the submodules can be automatically loaded and called by an external program. Functions in the internal submodule are not visible from the outside.

[0023] In this embodiment, the method for constructing an initialization submodule using the above-mentioned software platform includes the following: generating an initialization submodule using the software platform header file and software platform API list within the software platform; and after the initialization submodule call is completed, the third-party library obtains the address information of each API in the API list provided by the software platform. This enables the system to function correctly.

[0024] In this embodiment, the method for constructing a capability acquisition submodule using the above-mentioned software platform includes the following: The software platform loads the version number of the software platform, loads a list of corresponding user logical callback submodules, and loads a list of external submodules on which the corresponding third-party library depends, thereby automatically generating a capability acquisition submodule. When an external program calls the capability acquisition submodule, it obtains the version information of the software platform corresponding to the third-party library, obtains the list information of user logical callback submodules, obtains information on the external submodules on which this third-party library depends, and obtains information on all internal submodules of this third-party library. In this embodiment, the method for constructing internal submodules using the above-mentioned software platform includes the following: generating internal submodules based on the user function logical submodules of the software platform, and the internal submodules do not open an interface to the outside, but can be accessed simply by calling a capability acquisition function from an external program (third-party library).

[0025] Figure 3 is a flowchart showing how multiple third-party libraries according to the present invention make mutual calls to each other. As shown in Figure 3, in this embodiment, the method for verifying the legitimacy of the third-party library includes the following: The third-party library calling process is completed in cooperation between the software platform and the third-party library. By loading a dynamically linked library, the software platform loads the third-party library into its own software platform. The software platform calls the initialization submodule of the third-party library. The software platform calls the capability acquisition submodule of the third-party library, obtains the version number of the software platform corresponding to the third-party library, obtains a list of user callback submodules, and obtains address information and function parameter information for all internal submodules of the third-party library, as well as information on external submodules on which the third-party library depends. In the capability acquisition function calling process, the software platform simultaneously provides the third-party library with pointers to the submodules on which it depends (providing function pointers to internal functions in other third-party libraries on which the third-party library depends). If there are no external submodules on which the third-party library depends, the software platform provides the third-party library with a null pointer. In the calling process, the third-party library determines whether there are other third-party libraries on which it depends based on whether or not it is a null pointer. If a null pointer is obtained, the internal submodules of other third-party libraries that the third-party library depends on are not valid, but the functionality of those other internal submodules in the third-party library remains valid. The software platform compares the version number of the software platform corresponding to the obtained third-party library with its own version number. If the version number of the third-party library is greater than its own version number, it stops calling the third-party library; otherwise, it determines the legality (complies with the requirements) of the third-party library and continues calling it.

[0026] In this embodiment, the method for calling multiple third-party libraries includes the following: After the software platform has continuously called the third-party libraries, it is appropriate for the software platform to call the third-party libraries based on a list of user callback submodules and a list of internal submodules obtained from the third-party libraries. If the current third-party library needs to call an internal submodule of another third-party library during operation, the software platform transmits the submodule pointers that the current third-party library depends on to the current third-party library via the ability acquisition submodule, thereby causing the current third-party library to call the internal submodules in the other third-party libraries. After the call is completed, the software platform releases the requested resources by calling the release submodule in the third-party library. When the software platform calls a third-party library, it can not only know all the internal functions of other third-party libraries that the third-party library depends on, but the software platform itself can also provide the third-party library with pointers to those dependent functions. This allows the software platform to provide dependencies when interdependencies exist between third-party libraries, eliminating the need to manually modify the third-party libraries. Furthermore, by providing various function dependencies to the third-party libraries through the software platform, this method avoids the need to frequently modify the third-party libraries to realize dependencies on other third-party libraries, improving the development efficiency of third-party libraries and reducing the possibility of errors.

[0027] In this embodiment, the software platform constructs third-party libraries A and B. When the software platform calls third-party library A, third-party library A must depend on some internal functions of third-party library B. The software platform sends function pointers to the internal functions it depends on to third-party library A, and calls the corresponding internal functions from third-party library B.

[0028] In this embodiment, the software platform includes a software platform header file, a software platform API list containing API symbol information, a software platform version number, user logic generated by the software platform (expressed in the form of callback functions), custom logic designed by the user using the software platform (expressed in the form of regular functions), and a list of other third-party library functions on which the user logic depends (expressed in the form of symbol information associated with the functions). In the process of the software platform constructing mutually callable third-party libraries, it is first necessary to generate an initialization function for the third-party library, and the source code for this function is generated based on the software platform header file and the software platform API list containing API symbol information. Next, it is necessary to generate a capability acquisition function, and the source code for this function consists of the version number of the software platform itself, symbol information for the user logic callback function, and symbol information for the third-party library functions dependent on the user logic. It is also necessary to generate a release function, which is responsible for releasing requested resources before the third-party library is unloaded. Finally, it is necessary to generate a series of internal functions, which are custom logic designed by the user using the software platform. After the necessary functions have been generated, the software platform calls a C / C++ compiler and compiles the generated functions into an executable file for the third-party library.

[0029] In this embodiment, the software platform further includes dynamic link library loading functionality, function calling functionality, dependency function management functionality, and version number comparison functionality, execution functionality, and stop functionality. In the process of calling a mutually callable third-party library, the software platform must first load the third-party library using its dynamic link library loading function. After successful loading, the function call function calls the initialization function of the third-party library. Subsequently, the function call function calls the capability acquisition function of the third-party library, reading the compiled version number of the software platform, the user logic callback function, and the symbol information of the third-party functions on which the user logic depends, and inputting this information into the software platform. The software platform knows the relationship between the build version number of the third-party library and the version number of this software platform. If the version numbers are the same, or if the version number of this software platform is greater than the build version number of the third-party library, the software platform can continue calling the third-party library; otherwise, the calling process terminates. Simultaneously, the dependency function management function of the software platform needs to detect whether the dependent functions of the third-party library exist in the software platform. If they exist, it needs to provide the starting address of the dependent functions to the third-party library; otherwise, it needs to provide a null pointer to the third-party library. After the version number comparison function and dependency function management function have finished executing and returned a flag indicating that the program is continuously callable, the software platform executes the executable program function. During execution, the internal functions of the third-party library are freely called by the software platform and provide various functions to the software platform. If the third-party library needs to call its dependent functions, it first determines whether the dependent function is a null pointer or not. If it is not a null pointer, it continues calling; otherwise, it is assumed that the dependent library does not exist, the related function becomes invalid, and the current calling process returns to failure. If the third-party library does not need to be used, the software platform executes the program termination function. This function calls the third-party library's release function, and after the resources requested by the third-party library are released, the calling process terminates.

[0030] Specifically, this embodiment will explain the mutual calling method using the following two third-party libraries as examples: a third-party library for a general-purpose CRC16 algorithm and a third-party library for a calibration system. The third-party library for the calibration system performs an unlock operation on the target controller, depending on the general-purpose CRC16 algorithm. These two third-party libraries are loaded sequentially into the software platform, and the software platform uniformly provides the user with verification functions for the CRC16 algorithm and calibration functions for the calibration system. Conventional third-party libraries for general-purpose CRC16 algorithms require the derivation of external program-dependent API functions at compile time. Conventional third-party libraries for calibration systems are third-party libraries that depend on the general-purpose CRC16 algorithm, so their internal structure needs to incorporate the dependent functions of the third-party library for the general-purpose CRC16 algorithm, and in the loading process, the third-party library for the general-purpose CRC16 algorithm is loaded first. If the third-party library for the general-purpose CRC16 algorithm does not exist, this third-party library for the calibration system will fail to load, and the software platform will not be able to provide any functionality to the user. If a function in a third-party library for the general-purpose CRC16 algorithm is changed, for example, if the number of parameters in the CRC16 algorithm function increases from three to four, and the third-party library for the calibration system is not updated synchronously for some reason, then although both third-party libraries can be loaded normally, a breakdown occurs when the third-party library for the calibration system calls the CRC16 library. Therefore, the conventional method of libraries in software platforms referencing other libraries by static linking has the drawback of lacking interface definition checks during operation, as well as reducing the usability of the software platform and making it difficult to investigate problems when they occur. The software platform provided in this embodiment employs a different method, and its operation flow is as follows: The CRC16 third-party library and the third-party library for the calibration system both use the APIs that external programs depend on as internal functions, and do not derive any API functions.The software platform sequentially loads the CRC16 third-party library and the third-party library for the calibration system. The software platform calls the capability acquisition functions of these two third-party libraries to obtain the internal function list and definition information of each function, including function address information, parameter information, etc. The software platform analyzes the dependent functions of each third-party library, detects that the third-party library for the calibration system depends on the CRC16 third-party library, and substitutes the dependent function address information of the third-party library for the calibration system into the corresponding function address information of the CRC16 third-party library. The software platform analyzes the function definition information, including parameter information, of the dependent functions of each third-party library. If it finds that the internal API function definition of the CRC16 third-party library and the corresponding dependent function definition of the third-party library for the calibration system are different, it warns the user and prohibits the execution of the third-party library for the calibration system. After verifying that there are no problems with the dependencies between the third-party libraries, the software platform can successfully call these two third-party libraries and provide services to the user.

[0031] Example 2 In addition to Example 1, Example 2 further provides a software platform for the method of calling third-party library functions for the software platform in Example 1, and includes a software platform header file, a software platform API list, a software platform version number, a list of user logical callback submodules, a list of external submodules on which the third-party libraries depend, a user function logical submodule, and a C++ compiler.

[0032] In this embodiment, each submodule and function included in the software platform has already been described in detail in Embodiment 1, and will not be described in this embodiment.

[0033] Example 3 In addition to Example 1, Example 3 further provides a third-party library for the method of calling third-party library functions for the software platform in Example 1, and includes: an initialization submodule, a capability acquisition submodule, an internal submodule, and a release submodule.

[0034] In this embodiment, each submodule and function included in the third-party library is described in detail in Embodiment 1, and therefore will not be described in this embodiment.

[0035] Example 4 Figure 4 is a principle block diagram of the mutual calling system designed by the present invention. In addition to Example 1, Example 4 further provides a mutual calling system using the mutual calling method for third-party library functions for a software platform in Example 1, and includes: a build module that builds multiple third-party libraries; a verification module that verifies the legality of the third-party libraries; and a call module in which the multiple third-party libraries make mutual calls.

[0036] In this embodiment, the specific functions of each module have already been described in detail in Embodiment 1, and will therefore be omitted from this embodiment.

[0037] Example 5 In addition to the above embodiments, Embodiment 5 further provides a calling device, which includes a software platform and multiple third-party libraries. The software platform is suitable for building and calling third-party libraries. The third-party libraries can be called from each other by the software platform. In this embodiment, the functions of the software platform and third-party libraries are described in detail in the above embodiment and will not be described further in this embodiment.

[0038] In summary, the present invention realizes a single general-purpose call frame via a software platform by constructing multiple third-party libraries and having these libraries call each other, and functions registered by the third-party libraries on the software platform can be shared among all loaded third-party libraries. Thus, when a third-party library needs to call another third-party library, it does not need to load the other third-party library, and access to the other third-party library can be achieved by using a function table shared with the current third-party library that includes the other third-party library on the software platform. If no other third-party library is loaded, both the software platform and the current third-party library can be aware of this situation, thereby smoothly loading the current third-party library and providing some of its functions.

[0039] In some embodiments provided by this application, the disclosed apparatus and methods can, of course, be implemented in other ways. The embodiments of the apparatus described above are merely illustrative; for example, the flowcharts and block diagrams in the drawings illustrate the implementable architectures, functions, and operations of the apparatus, methods, and computer program products according to some embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or part of code containing one or more executable instructions for performing a given logical function. In some alternative implementations, the functions represented in the blocks may occur in an order different from that shown in the drawings. For example, two consecutive blocks can actually be executed substantially in parallel, and sometimes in reverse order depending on the related functions. It should also be noted that each block in a block diagram and / or flowchart, and combinations of blocks in a block diagram and / or flowchart, may be implemented in a dedicated hardware-based system that performs a given function or operation, or in a combination of dedicated hardware and computer instructions.

[0040] Furthermore, in each embodiment of the present invention, each functional module may be integrated to form a single independent part, each module may exist individually, or two or more modules may be integrated to form a single independent part.

[0041] The above functions can be implemented in the form of software function modules and, when sold or used as independent products, can be stored on a computer-readable storage medium. Based on this understanding, the technical solutions of the present invention, or parts of them that contribute essentially to the prior art, or parts of such technical solutions, can be represented in the form of a software product. The computer software product is stored on a storage medium and contains a plurality of commands that cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage mediums include: various media capable of storing program code, such as U disks, removable disks, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0042] By illustrating the preferred embodiments of the present invention described above, those skilled in the art can make various changes and modifications to the above-described content without departing from the technical spirit of the present invention. The technical scope of the present invention is not limited to the contents of the specification and must be determined based on the claims.

Claims

1. A method for constructing a third-party library in a method for mutually calling third-party library functions for a software platform, which is performed by a computer under software control, The software platform constructs at least one third-party library, that is, the software platform constructs an initialization submodule, a capability acquisition submodule, and an internal submodule in the third-party library. The method for building an initialization submodule using a software platform is: A method for constructing a third-party library, performed by a computer under software control, comprising generating the initialization submodule using the software platform header files and software platform API list within the software platform, and after the initialization submodule call is completed, the third-party library obtains address information for each API in the API list provided by the software platform.

2. A method for constructing a third-party library in a method for mutually calling third-party library functions for a software platform, which is performed by a computer under software control, The software platform constructs at least one third-party library, that is, the software platform constructs an initialization submodule, a capability acquisition submodule, and an internal submodule in the third-party library. The method for building capability acquisition submodules using a software platform is: A method for constructing a third-party library, performed by a computer under software control, comprising: the software platform loading the version number of the software platform, loading a list of corresponding user logical callback submodules, and loading a list of external submodules on which the third-party library depends to generate the capability acquisition submodule; and when an external program calls the capability acquisition submodule, it obtains version information of the software platform corresponding to the third-party library, obtains a list of user logical callback submodules, obtains a list of external submodules on which the third-party library depends, and obtains information on all internal submodules of the third-party library.

3. The method for building internal submodules using a software platform is: The method according to claim 1 or 2, characterized in that it includes generating the internal submodule based on the user function logical submodule of the software platform.

4. This further includes constructing a release submodule in the aforementioned third-party library, The method according to 1 or 2, characterized in that the release submodule is suitable for automatically releasing the requested resources when the third-party library is unloaded.

5. A method for verifying the legality of a third-party library in a method of mutual calling of third-party library functions for a software platform, performed by a computer under software control, The process involves loading a third-party library into a software platform, the software platform calling the initialization submodule of the third-party library, calling the capability acquisition submodule, obtaining the version number of the software platform corresponding to the third-party library, obtaining a list of user callback submodules, obtaining address information and function parameter information for all internal submodules of the third-party library, and obtaining a list of external submodules on which the third-party library depends. The software platform provides the third-party library with pointers to the submodules on which it depends. If the external submodule on which the third-party library depends does not exist, the software platform provides the third-party library with a null pointer. The aforementioned third-party library, in the calling process, determines whether or not there are other third-party libraries on which it depends, based on whether or not it is a null pointer. If it is a null pointer, then other internal submodules of the third-party library on which the said third-party library depends are not valid, but the functionality of the other internal submodules in the said third-party library is still valid. A method for verifying the legality of a third-party library, performed by a computer under software control, characterized in that the software platform compares the version number of the software platform corresponding to the acquired third-party library with its own version number, and if the version number of the third-party library is greater than its own version number, stops calling the third-party library, and otherwise continues calling the third-party library.

6. The method according to claim 5, characterized in that the initialization submodule is constructed by employing the method according to claim 2.

7. The method according to claim 5, characterized in that the capability acquisition submodule is constructed by employing the method according to claim 3.

8. The method according to claim 5, characterized in that the internal submodule is constructed by employing the method according to claim 4.

9. A computer-readable storage medium storing computer-readable instructions, wherein when it is executed by at least one processor, the method according to any one of claims 1 to 4 is performed. Alternatively, a storage medium characterized by being subjected to the method described in claim 5.

10. When executed on a computer, the computer can perform the method according to any one of claims 1 to 4. Alternatively, a program characterized in that a computer can perform the method described in claim 5.

Images