CN108920379B - Method and device for capturing lua code exception - Google Patents
Method and device for capturing lua code exception Download PDFInfo
- Publication number
- CN108920379B CN108920379B CN201810790898.5A CN201810790898A CN108920379B CN 108920379 B CN108920379 B CN 108920379B CN 201810790898 A CN201810790898 A CN 201810790898A CN 108920379 B CN108920379 B CN 108920379B
- Authority
- CN
- China
- Prior art keywords
- lua
- function
- code
- exception handling
- lua code
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
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/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- 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/362—Software debugging
- G06F11/366—Software debugging using diagnostics
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method and a device for capturing lua code exception, wherein the method comprises the following steps: setting that the lua code is called through an exception handling function when the lua code is called each time; acquiring a return value of an exception handling function and pushing the return value of the exception handling function into an lua stack, wherein the return value of the exception handling function at least comprises whether an lua code is abnormal or not and the return value when the lua code is normal or error information when the lua code is abnormal; if the lua code is abnormal, the application language function is called reversely to transfer the error information in the lua stack to the application language function. According to the scheme provided by the embodiment of the application, developers can acquire error information of the lua layer at the first time in the app development process or after the app is officially released and used, and can timely position an error scene with a very small probability and timely repair the error scene.
Description
Technical Field
The invention belongs to the technical field of exception capture, and particularly relates to a method and a device for capturing lua code exception.
Background
In the related art, the lua language itself uses few scenes, and the application of using lua in android is very few, so that a relatively universal method capable of capturing lua exception in android is not available at present.
At present, lua development is that a log is printed to a terminal in a development stage, then a bug is positioned, and after a version is released formally, the problem of the app in the actual operation process can be traced by means hardly.
At present, most lua development and debugging are matched with a development environment, and when a mobile terminal runs, the mobile terminal is connected to a development machine to capture logs in real time. The method is effective in the development stage, but some bugs need to be triggered in a specific scene, and after products are delivered, the bugs cannot grab logs and cannot be located due to the problems.
The inventor discovers that in the process of implementing the application: the key of the problem is that in the actual operation process of the app, when an error occurs or the app crashes, the app can hardly capture effective log information, and after the log information is captured, development and testing personnel also need to obtain the information through some means to perform next positioning, so that the problem is solved.
Disclosure of Invention
Embodiments of the present invention provide a method and an apparatus for capturing an lua code exception, so as to solve at least one of the above technical problems.
In a first aspect, an embodiment of the present invention provides a method for trapping an lua code exception, including:
setting that the lua code is called through an exception handling function each time the lua code is called; obtaining a return value of an exception handling function and pushing the return value of the exception handling function into an lua stack, wherein the return value of the exception handling function at least comprises whether the lua code is abnormal or not and the return value when the lua code is normal or error information when the lua code is abnormal; and if the lua code is abnormal, calling the java function reversely to transfer error information in the lua stack to the java function.
In a second aspect, an embodiment of the present invention provides an apparatus for trapping an lua code exception, including: the setting module is configured to set that the lua code is called through an exception handling function each time the lua code is called; a return value processing module configured to obtain a return value of an exception handling function and push the return value of the exception handling function into an lua stack, where the return value of the exception handling function at least includes whether the lua code is abnormal, and a return value when the lua code is normal or error information when the lua code is abnormal; and the transfer module is configured to call the java function reversely to transfer the error information in the lua stack to the java function if the lua code is abnormal.
In a third aspect, an electronic device is provided, comprising: at least one processor, and a memory communicatively coupled to the at least one processor, wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the steps of the method of capturing lua code exceptions of any of the embodiments of the present invention.
In a fourth aspect, embodiments of the present invention also provide a computer program product, which includes a computer program stored on a non-volatile computer-readable storage medium, the computer program including program instructions, which, when executed by a computer, cause the computer to perform the steps of the method for capturing an exception in lua code according to any of the embodiments of the present invention.
According to the method and the device, the exception handling function is used for calling the lua code, and then the exception is transmitted to the application language function, so that even if the lua code is in error and crashes, the exception handling function cannot be crashed, and error information is put on the lua stack and transmitted. Therefore, developers can acquire error information of the lua layer at the first time no matter in the process of app development or after the app is formally released and used, error scenes with very small probability can be timely positioned, and the error scenes can be timely repaired.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on the drawings without creative efforts.
FIG. 1 is a flow chart of a method for catching an lua code exception according to an embodiment of the present invention;
FIG. 2 is a flow diagram of another method for catching an lua code exception according to an embodiment of the present invention;
FIG. 3 is a flowchart of yet another method for trapping lua code exceptions, according to an embodiment of the present invention;
FIG. 4 is a schematic diagram illustrating an exception trap flow of a method for trapping an exception of an lua code according to an embodiment of the present invention;
FIG. 5 is a block diagram of an apparatus for catching an lua code exception according to an embodiment of the present invention;
fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
In the following, embodiments of the present application will be described, and then experimental data will be used to confirm what different and advantageous effects can be achieved in the scheme of the present application compared with the prior art.
Referring to fig. 1, a flowchart of an embodiment of a method for capturing an lua code exception according to the present application is shown, where the method for capturing an lua code exception according to the present embodiment may be applied to an APP (application program) containing an lua code.
As shown in fig. 1, in step 101, it is set that the lua code is called by an exception handling function each time the lua code is called;
then, in step 102, obtaining the return value of the exception handling function and pushing the return value of the exception handling function to the lua stack;
finally, in step 103, if the lua code is abnormal, the application language function is called backward to pass the error information in the lua stack to the application language function.
In this embodiment, for step 101, the means for trapping the lua exception first wraps the lua code with an exception handling function so that each time the lua code is called, it is called by the exception handling function. In some alternative embodiments, the exception handling function includes lua _ pcall and lua _ xpcals. Thereafter, for step 102, the means for catching the lua exception obtains a return value of the exception handling function and pushes the return value into the lua stack, where the return value of the exception handling function at least includes whether the lua code is abnormal, such as true or false, or true or nil, and a return value when the lua code is normal or error information when the lua code is abnormal. In a further embodiment, additional information or extension information of the error information may also be included, such as descriptive information of the error information or the like. Finally, for step 103, if a code exception is raised from the return value in the lua stack, the application language function is called backward to pass the error information in the lua stack to the application language function. The language function can be a java function, a C/C + + function, a Python function or other functions for writing APP so as to transfer errors from the bottom layer to the application layer.
According to the method, the lua code is called by using the exception handling function, and then the exception is transmitted to the application language function, so that even if the lua code is broken down due to an error, the exception handling function cannot be broken down, and error information is placed on the lua stack and transmitted. Therefore, developers can acquire error information of the lua layer at the first time no matter in the process of app development or after the app is formally released and used, error scenes with very small probability can be timely positioned, and the error scenes can be timely repaired.
With further reference to FIG. 2, shown is a flow diagram of another method of the present application for catching lua code exceptions.
As shown in fig. 2, in step 201, the error information captured by the application language function is thrown to the upper layer;
in step 202, error information thrown by the application language function is captured and uploaded at the upper layer.
In this embodiment, for step 201, the means for trapping the lua code exception throws an error message received by the application language function for the lua code passed by the lua stack to the upper layer. Then, in step 202, the error information thrown by the application language function is captured at the upper layer and uploaded to the server of the APP, so that the server can know the abnormality of the lua in real time.
With further reference to FIG. 3, shown is a flow diagram of yet another method of the present application of catching lua code exceptions. The flow is mainly a refinement step to step 101 in fig. 1.
As shown in FIG. 3, in step 301, the lua code is encapsulated in a preset function;
in step 302, the calling lua code is modified to call a preset function through an exception handling function.
In this embodiment, for step 301, the means for catching the lua code exception encapsulates the lua code in a preset function. Thereafter, for step 302, the means for trapping the lua code exception modifies the instruction calling the lua code to call a predetermined function through an exception handling function, for example, by modifying a pointer pointing to the predetermined function calling the lua code to point to an exception handling function (e.g., lua _ pcall). Therefore, the error-prone lua code can be packaged, and even if the lua code is in error and crashes, capture of the exception by the exception handling function is not influenced.
The following presents a brief description of the lua and the interaction between the lua and other languages to enable those skilled in the art to better understand the concepts of the present application.
lua is an extended programming language designed to support general purpose procedural programming and has associated data description facilities. And simultaneously, good support is provided for object-oriented programming, functional programming and data-driven programming. To summarize, lua is a lightweight language and supports multiple programming paradigms, with any desirable adaptation of the language.
As an extension language, lua has no notion of a "main" program, and can only work embedded in a host program, which is called an embedded program or simply a host. The host program can call a function to execute a small lua code, read and write lua variable, and register the C function to make the lua code call.
The lua program does not generally run separately, but it is simpler to do so, although it is also possible. The standard lua virtual machine is written through C language, and the function of the lua is generally expanded through C/C + +, so that the interface compatibility speed is higher.
The stack of lua is highlighted here for convenience of description later.
The data exchange between the lua virtual machine and the C/C + + is basically interactive through constructing a virtual stack by the lua, and whenever the lua calls the C, the called function obtains a new stack which is independent of the stack of the C function and the previous lua stack. It contains all the parameters that the lua passes to the C function, which puts the result to be returned on the stack for return to the caller.
Based on the characteristic of the lua as "parasitic work", the idea of mutual calling between Java and lua languages is obvious, that is, jni (Java Native Interface) is used as an intermediary.
In order to solve the above-mentioned drawbacks of the prior art, some products of the prior art may be solved by the following methods:
after the general app crashes, the system layer may retain some crash information, and after the app is started again, the crash information may be sent to the background server.
The inventors have discovered that, first, this approach requires the operating system level to be able to save crash information, which is not supported by all systems; secondly, the app needs to read the log related to the app from the system; finally, the app itself needs to have a server capable of receiving and storing these logs, which is a very large project.
The method provided by the embodiment of the application ensures that the effective log can be captured certainly by the following method and uploaded to the server. Specifically, refer to fig. 4, which shows a schematic diagram of an anomaly capture process according to an embodiment of the present application. It should be noted that, although the embodiment is only given in which the exception handling function is lua _ pcall and the application language function is java function in this embodiment, the present disclosure is not limited to this embodiment, and those skilled in the art may obtain other combination schemes according to the following embodiments, and details are not described herein again.
1) Functions such as lua _ pcall and pcall are adopted to run the lua code, so that the lua is not crashed in the C layer in the running process, and the application is not crashed even if errors occur;
2) after the lua layer makes an error, reversely calling java codes at the C layer and carrying out a throw exception to the java layer;
3) capturing abnormal information by a java layer;
4) uploading the exception information to the server through the busy tool of Tencent.
As shown in figure 4 of the drawings,
1) each time the lua code is called in the android, the lua code is called through the lua _ pcall, and the function does not crash when the lua code goes wrong, but the error information is put on the lua stack.
2) Judge whether each call is in error by the return value of lua _ pcall (has errors? ) And if no error exists, returning to the step 1) and continuing to execute.
3) If an error occurs, the java function (call java function) is called reversely through the jni function, and when the call is carried out, the error information on the lua stack is transmitted to the java function at the same time.
4) And (4) throwing an exception (throw exception) to an upper layer in the java function, wherein exception information is error information of the lua.
5) An android bug tool provided by some Internet company is simultaneously run in the android app, and the tool can capture exception (catch exception) thrown by java functions.
6) after capturing the exception, the android bugly is uploaded to a bug server (send to server) through the network.
Therefore, exception capture and uploading of lua are completed completely, and android developers can check error information uploaded by the app and repair the error information in time by logging in the bugly server every day.
According to the scheme, developers can acquire error information of the lua layer at the first time no matter in the app development process or after the app is officially released and used, error scenes with very small probability can be timely positioned, and the error scenes can be timely repaired.
Referring to fig. 5, a block diagram of an apparatus for trapping an lua code exception according to an embodiment of the present invention is shown.
As shown in FIG. 5, the apparatus 500 for trapping an lua code exception according to the present invention includes a setting module 510, a return value processing module 520, and a passing module 530.
Wherein the setting module 510 is configured to set that the lua code is called by an exception handling function each time the lua code is called; a return value processing module 520, configured to obtain a return value of the exception handling function and push the return value of the exception handling function to the lua stack, where the return value of the exception handling function at least includes whether the lua code is abnormal or not, and a return value when the lua code is normal or error information when the lua code is abnormal; and a pass module 530 configured to call the application language function backwards to pass error information in the lua stack to the application language function if the lua code is abnormal.
In some optional embodiments, the apparatus 500 for trapping lua code exception further includes an error throwing module (not shown in the figure) and a trapping uploading module (not shown in the figure). The error throwing module is configured to throw the error information captured by the application language function to an upper layer; and the capturing and uploading module is configured to capture and upload error information thrown by the application language function.
In some optional embodiments, the setup module 510 further includes an encapsulation module and a call modification module. The encapsulation module is configured to encapsulate the lua code in a preset function; and a call modification module configured to modify the call lua code to call the preset function through the exception handling function.
It should be understood that the modules recited in fig. 5 correspond to various steps in the methods described with reference to fig. 1, 2, and 3. Thus, the operations and features described above for the method and the corresponding technical effects are also applicable to the modules in fig. 5, and are not described again here.
It is to be noted that the modules in the embodiments of the present disclosure are not intended to limit the scheme of the present disclosure, and for example, the setting module may be described as a module that sets the lua code to be called by the exception handling function each time the lua code is called. In addition, the related functional modules may also be implemented by a hardware processor, for example, the setting module may also be implemented by a processor, which is not described herein again.
In other embodiments, an embodiment of the present invention further provides a non-volatile computer storage medium, where the computer storage medium stores computer-executable instructions, and the computer-executable instructions may perform the method for capturing the lua code exception in any of the above method embodiments;
as one embodiment, a non-volatile computer storage medium of the present invention stores computer-executable instructions configured to:
setting that the lua code is called through an exception handling function each time the lua code is called;
obtaining a return value of the exception handling function and pushing the return value of the exception handling function to an lua stack, wherein the return value of the exception handling function at least comprises whether the lua code is abnormal or not and the return value when the lua code is normal or error information when the lua code is abnormal;
if the lua code is abnormal, an application language function is called reversely to transfer error information in the lua stack to the application language function.
As a non-volatile computer readable storage medium, it can be used to store non-volatile software programs, non-volatile computer executable programs, and modules, such as program instructions/modules corresponding to the method for capturing lua code exception in the embodiment of the present invention. One or more program instructions are stored in a non-transitory computer readable storage medium, which when executed by a processor, perform a method of trapping lua code exceptions in any of the method embodiments described above.
The non-volatile computer-readable storage medium may include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function; the storage data area may store data created from use of a device that captures an lua code exception, and the like. Further, the non-volatile computer-readable storage medium may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some embodiments, the non-transitory computer readable storage medium optionally includes memory located remotely from the processor, which may be connected over a network to the means for catching the lua code exception. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
Embodiments of the present invention also provide a computer program product comprising a computer program stored on a non-transitory computer readable storage medium, the computer program comprising program instructions which, when executed by a computer, cause the computer to perform any of the above methods of catching lua code exceptions.
Fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present invention, and as shown in fig. 6, the electronic device includes: one or more processors 610 and a memory 620, with one processor 610 being an example in fig. 6. The apparatus of the method of trapping an lua code exception may further include: an input device 630 and an output device 640. The processor 610, the memory 620, the input device 630, and the output device 640 may be connected by a bus or other means, such as the bus connection in fig. 6. The memory 620 is a non-volatile computer-readable storage medium as described above. The processor 610 executes various functional applications of the server and data processing by running nonvolatile software programs, instructions and modules stored in the memory 620, that is, implements the method for capturing the lua code exception of the above method embodiment. The input device 630 may receive input numeric or character information and generate key signal inputs related to user settings and function controls of the information delivery device. The output device 640 may include a display device such as a display screen.
The product can execute the method provided by the embodiment of the invention, and has corresponding functional modules and beneficial effects of the execution method. For technical details that are not described in detail in this embodiment, reference may be made to the method provided by the embodiment of the present invention.
As an embodiment, the electronic device is applied to a neural network language model, and includes: at least one processor; and a memory communicatively coupled to the at least one processor; wherein the memory stores instructions executable by the at least one processor to cause the at least one processor to:
setting that the lua code is called through an exception handling function each time the lua code is called;
obtaining a return value of the exception handling function and pushing the return value of the exception handling function to an lua stack, wherein the return value of the exception handling function at least comprises whether the lua code is abnormal or not and the return value when the lua code is normal or error information when the lua code is abnormal;
if the lua code is abnormal, an application language function is called reversely to transfer error information in the lua stack to the application language function.
The electronic device of the embodiments of the present application exists in various forms, including but not limited to:
(1) a mobile communication device: such devices are characterized by mobile communications capabilities and are primarily targeted at providing voice, data communications. Such terminals include smart phones (e.g., iphones), multimedia phones, functional phones, and low-end phones, among others.
(2) Ultra mobile personal computer device: the equipment belongs to the category of personal computers, has calculation and processing functions and generally has the characteristic of mobile internet access. Such terminals include: PDA, MID, and UMPC devices, etc., such as ipads.
(3) A portable entertainment device: such devices can display and play multimedia content. Such devices include audio and video players (e.g., ipods), handheld game consoles, electronic books, as well as smart toys and portable car navigation devices.
(4) The server is similar to a general computer architecture, but has higher requirements on processing capability, stability, reliability, safety, expandability, manageability and the like because of the need of providing highly reliable services.
(5) And other electronic devices with data interaction functions.
The above-described embodiments of the apparatus are merely illustrative, and the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware. With this understanding in mind, the above-described technical solutions may be embodied in the form of a software product, which can be stored in a computer-readable storage medium, such as ROM/RAM, magnetic disk, optical disk, etc., and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the methods of the various embodiments or some parts of the embodiments.
Finally, it should be noted that: the above examples are only intended to illustrate the technical solution of the present invention, but not to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions of the embodiments of the present invention.
Claims (8)
1. A method of trapping lua code exceptions, comprising:
setting that the lua code is called through an exception handling function each time the lua code is called;
obtaining a return value of the exception handling function and pushing the return value of the exception handling function to an lua stack, wherein the return value of the exception handling function at least comprises whether the lua code is abnormal or not and the return value when the lua code is normal or error information when the lua code is abnormal;
if the lua code is abnormal, an application language function is called reversely to transfer error information in the lua stack to the application language function;
throwing the error information captured by the application language function to an upper layer;
and capturing the error information thrown by the application language function at the upper layer, capturing the abnormality thrown by the application language function by using an android bugly tool, and uploading the abnormality thrown by the application language function to a bugly server through a network, so that a developer can check the code abnormality in real time.
2. The method of claim 1, wherein the setting calling the lua code through an exception handling function each time the lua code needs to be called comprises:
encapsulating the lua code in a preset function;
and modifying the calling lua code to call the preset function through an exception handling function.
3. The method of claim 1 or 2, wherein the exception handling function comprises lua _ pcall and lua _ xpcals.
4. The method of claim 3, wherein the application language functions include C/C + + functions, Java functions, and Python functions.
5. An apparatus to trap lua code exceptions, comprising:
the setting module is configured to set that the lua code is called through an exception handling function each time the lua code is called;
a return value processing module configured to obtain a return value of the exception handling function and push the return value of the exception handling function to an lua stack, where the return value of the exception handling function at least includes whether the lua code is abnormal, and a return value when the lua code is normal or error information when the lua code is abnormal;
a transfer module configured to call an application language function in reverse to transfer error information in the lua stack to the application language function if the lua code is abnormal;
an error throwing module configured to throw the error information captured by the application language function to an upper layer;
and the capturing and uploading module is configured to capture the error information thrown by the application language function and capture the abnormity thrown by the application language function by using an android bugly tool, and upload the abnormity thrown by the application language function to a bugly server through a network, so that a developer can check the code abnormity in real time.
6. The apparatus of claim 5, wherein the setup module comprises:
an encapsulation module configured to encapsulate the lua code in a preset function;
and the calling modification module is configured to modify the calling lua code into a mode of calling the preset function through an exception handling function.
7. An electronic device, comprising: at least one processor, and a memory communicatively coupled to the at least one processor, wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the steps of the method of any one of claims 1 to 4.
8. A storage medium having stored thereon a computer program, characterized in that the program, when being executed by a processor, is adapted to carry out the steps of the method of any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810790898.5A CN108920379B (en) | 2018-07-18 | 2018-07-18 | Method and device for capturing lua code exception |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810790898.5A CN108920379B (en) | 2018-07-18 | 2018-07-18 | Method and device for capturing lua code exception |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108920379A CN108920379A (en) | 2018-11-30 |
| CN108920379B true CN108920379B (en) | 2022-01-11 |
Family
ID=64415022
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810790898.5A Active CN108920379B (en) | 2018-07-18 | 2018-07-18 | Method and device for capturing lua code exception |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108920379B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111124726B (en) * | 2019-12-09 | 2024-01-26 | 上海移远通信技术股份有限公司 | Method and device for detecting abnormality of open modem port |
| CN112181834B (en) * | 2020-09-29 | 2022-02-25 | 苏州亿歌网络科技有限公司 | Method, device and equipment for debugging lua based on gdb and storage medium |
| CN114610643B (en) * | 2022-03-23 | 2022-11-15 | 一点灵犀信息技术(广州)有限公司 | Code performance detection method and device and electronic equipment |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104111855A (en) * | 2014-07-29 | 2014-10-22 | 广东能龙教育股份有限公司 | Method for dynamic update of iOS (Iphone Operation System) client based on Lua |
| CN105278445A (en) * | 2015-11-05 | 2016-01-27 | 广州擎天实业有限公司 | Secondary development method of synchronous generator excitation regulator control program |
-
2018
- 2018-07-18 CN CN201810790898.5A patent/CN108920379B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104111855A (en) * | 2014-07-29 | 2014-10-22 | 广东能龙教育股份有限公司 | Method for dynamic update of iOS (Iphone Operation System) client based on Lua |
| CN105278445A (en) * | 2015-11-05 | 2016-01-27 | 广州擎天实业有限公司 | Secondary development method of synchronous generator excitation regulator control program |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108920379A (en) | 2018-11-30 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108920379B (en) | Method and device for capturing lua code exception | |
| CN110704847B (en) | Vulnerability scanning method and related device | |
| CN108874677B (en) | Android terminal and test method and system thereof | |
| CN108763060A (en) | Native layers of collapse source tracing method, device, storage medium and terminal in android system | |
| CN109002320B (en) | Updating method, system, electronic device and storage medium for software development kit | |
| CN108255719B (en) | Application program dump file acquisition method and device and electronic equipment | |
| CN107391219B (en) | Function Compilation Method and device | |
| CN107370804B (en) | Software application processing method and device | |
| CN105975367B (en) | Test method and device for mobile equipment | |
| CN104731566A (en) | Testing device, method and system for IDE (Integrated Development Environment) | |
| CN111782525B (en) | Java method remote debugging method and device | |
| CN111209193A (en) | Program debugging method and device | |
| US20170163787A1 (en) | Method and electronic device for upgrading or downgrading system | |
| CN106997313B (en) | Signal processing method and system of application program and terminal equipment | |
| CN109471693A (en) | Proprietary component is mapped to method, medium and the equipment of Cross-border congestion management system | |
| CN103678125A (en) | Method and system for debugging codes | |
| CN112988267A (en) | Loading method and device, storage medium and electronic equipment | |
| CN111128139A (en) | Non-invasive voice test method and device | |
| CN102937934A (en) | Capturing telemetry data through a dynamic language engine | |
| CN114840225B (en) | Application deployment method and device, storage medium and electronic device | |
| CN110147294A (en) | Acquisition methods, device, terminal and the computer readable storage medium of Debugging message | |
| CN105975387A (en) | Method and device for capturing terminal debugging information | |
| CN111414270B (en) | Exception handling method and device | |
| CN113765862B (en) | Game protocol testing method, device, equipment and computer readable storage medium | |
| CN110750738B (en) | Method for adding tag to anchor and electronic equipment |
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 | ||
| CB02 | Change of applicant information |
Address after: 215123 building 14, Tengfei Innovation Park, 388 Xinping street, Suzhou Industrial Park, Suzhou City, Jiangsu Province Applicant after: Sipic Technology Co.,Ltd. Address before: 215123 building 14, Tengfei Innovation Park, 388 Xinping street, Suzhou Industrial Park, Suzhou City, Jiangsu Province Applicant before: AI SPEECH Co.,Ltd. |
|
| CB02 | Change of applicant information | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| PE01 | Entry into force of the registration of the contract for pledge of patent right |
Denomination of invention: Methods and Devices for Capturing Lua Code Exceptions Effective date of registration: 20230726 Granted publication date: 20220111 Pledgee: CITIC Bank Limited by Share Ltd. Suzhou branch Pledgor: Sipic Technology Co.,Ltd. Registration number: Y2023980049433 |
|
| PE01 | Entry into force of the registration of the contract for pledge of patent right |