CN112612712B - Software breakpoint debugging method and device based on extended script - Google Patents
Software breakpoint debugging method and device based on extended script Download PDFInfo
- Publication number
- CN112612712B CN112612712B CN202011599164.2A CN202011599164A CN112612712B CN 112612712 B CN112612712 B CN 112612712B CN 202011599164 A CN202011599164 A CN 202011599164A CN 112612712 B CN112612712 B CN 112612712B
- Authority
- CN
- China
- Prior art keywords
- software
- debugging
- function
- script
- python
- 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/3632—Software debugging of specific synchronisation aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/37—Compiler construction; Parser generation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Software Systems (AREA)
- Devices For Executing Special Programs (AREA)
- Debugging And Monitoring (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a software breakpoint debugging method and device based on an extended script, wherein the method comprises the following steps: an extended script generating step, namely compiling a function of software compiled by a compiling type language into an extended script for realizing the function by using an interpretation language, and adding a debugging anchor point in the extended script; a conversion step of converting a link library of software written in a compiling type language related to the function into a link library which can be called by an interpretation language; and debugging, namely performing breakpoint debugging on the software by a debugger based on the debugging anchor point added in the extension script. The problem that a software debugging method in the prior art is only suitable for the development environment and cannot debug the software in the running process is solved, synchronous debugging of the running software based on the extension script is achieved, the memory occupation is small, and the problem can be reproduced and conveniently checked.
Description
Technical Field
The invention relates to the technical field of computer program debugging, in particular to a software breakpoint debugging method and device based on an extended script.
Background
Software is a set of computer data and instructions organized in a specific order, and software development refers to a process of building a software system or software parts in a system according to user requirements, and is a system engineering including requirement capture, requirement analysis, design, implementation, debugging and testing.
Various unexpected software problems inevitably occur in the software development and use process, and the existing methods for locating the software problems comprise running log analysis, memory DUMP analysis and code single-step debugging.
The above problem of the positioning software is disadvantageous in that: (1) running the log requires that the debugging instructions for generating the log are written into the corresponding position of the software program in advance in a hard-coded mode. The debugging instructions written by hard coding are not easy to change and delete, and the software program written with the debugging instructions needs to be compiled, linked and operated again, so that the original operating environment of the software error is likely to be lost/changed, and the software error is not easy to reproduce. (2) The memory DUMP analysis needs to store a copy of the current entire occupied memory on a disk, a large amount of memory is occupied for each analysis, the analysis result is static, and the steps of the memory DUMP are repeatedly executed if dynamic data are to be checked. (3) The code debugging needs to have all the codes of the software and the corresponding development environment, and if the software is protected by a shell, the codes are mixed or encrypted, and the single-step debugging cannot be carried out.
In addition, the software debugging methods all require that a debugger has the relevant codes and development environment of software, and a relatively common use scene is used by the developer when the developer checks found problems in the software development stage. These methods are not suitable for a scenario that a software problem needs to be dynamically debugged in real time in a user running environment during a software using stage, that is, in the prior art, debugging work cannot be performed while software is running.
Disclosure of Invention
The present invention is directed to one or more of the above technical drawbacks of the prior art, and provides a specific method for solving the above technical problems.
A software breakpoint debugging method based on extended scripts comprises the following steps:
an extended script generating step, namely compiling a function of software compiled by a compiling type language into an extended script for realizing the function by using an interpretation language, and adding a debugging anchor point in the extended script;
a conversion step of converting a link library of software written in a compiling type language related to the function into a link library which can be called by an interpretation language;
and debugging, namely performing breakpoint debugging on the software by a debugger based on the debugging anchor point added in the extension script.
Further, the compiled language is C + +, the interpreted language is Python, and the debugger is a Python debugger.
Further, the extended script generating step is operated as: defining a set of interfaces F ═ { F) for said software 1 ，f 2 ，f 3 ，…，f n-1 ，f n F is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is the function of the extended scriptNumber interface, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script.
Further, the converting step operates to: and converting the link library DLL of the software written by the compiling language C + + related to the function into the link library pyd which can be called by the interpreted language Python.
Further, the debugging step operates as: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script waits for external additional debugging at an anchor point X; a Python debugger executes additional debugging, and the codes of the extended script are interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When is, p is x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
The invention also provides a software breakpoint debugging device based on the extended script, which comprises:
the extension script generating unit is used for compiling a function of software compiled by a compiling type language into an extension script for realizing the function by using an interpretation language and adding a debugging anchor point into the extension script;
a conversion unit that converts a link library of software written in a compiled language to which the function relates into a link library that can be called by an interpreted language;
and the debugging unit is used for carrying out breakpoint debugging on the software by the debugger based on the debugging anchor point added in the extension script.
Further, the compiled language is C + +, the interpreted language is Python, and the debugger is a Python debugger.
Further, the extended script generating unit performs the operations of: statorDefining the interface set F ═ { F) of the software 1 ，f 2 ，f 3 ，…，f n-1 ，f n H, where f is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is a function interface of the extended script, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script.
Still further, the conversion unit is operative to: and converting the link library DLL of the software written by the compiling language C + + related to the function into the link library pyd which can be called by the interpreted language Python.
Further, the debugging unit performs the operations of: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script waits for external additional debugging at an anchor point X; the Python debugger executes additional debugging, and the code of the extended script is interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When p is greater than p x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
The invention has the technical effects that: the invention provides a software breakpoint debugging method and device based on an extended script, wherein the method comprises the following steps: an extended script generating step, namely compiling a function of software compiled by a compiling type language into an extended script for realizing the function by using an interpretation language, and adding a debugging anchor point in the extended script; a conversion step of converting a link library of software written in a compiling type language related to the function into a link library which can be called by an interpretation language; and debugging, namely performing breakpoint debugging on the software by a debugger based on the debugging anchor point added in the extension script. The invention solves the technical problems that the software debugging method in the prior art is only suitable for the condition of a development environment and can not debug the software in the running process, realizes breakpoint debugging in the running process of the software through an extension script, improves the positioning accuracy of software errors, can reproduce the faults of the software and can debug the software in real time, directly and formally replaces some sub-modules of the software with the extension script to realize the effect of dynamically debugging the service flow of the sub-modules, solves the technical problems that the traditional direct C + + realized sub-module can not dynamically debug the service flow, solves the technical problems that the analysis result in the prior art is static, if the dynamic data is checked, the step of repeatedly executing a memory DUMP is needed to cause overlarge memory occupation, and realizes data exchange between C + + and Python, the C + + memory data structure and the Python memory data structure are mutually converted, so that the Python can transmit parameters to the C + + interface and read return results without concerning differences, synchronous debugging of running software based on extension scripts can be realized, the memory occupation is small, and problems can be reproduced and conveniently checked.
Drawings
Other features, objects and advantages of the present application will become more apparent upon reading of the following detailed description of non-limiting embodiments thereof, made with reference to the accompanying drawings.
FIG. 1 is a flowchart of a software breakpoint debugging method based on extended scripts according to an embodiment of the present invention.
Fig. 2 is a block diagram of an extended script-based software breakpoint debugging apparatus according to an embodiment of the present invention.
Detailed Description
The present application will be described in further detail with reference to the drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the relevant invention and not restrictive of the invention. It should be noted that, for convenience of description, only the portions related to the present invention are shown in the drawings.
It should be noted that, in the present application, the embodiments and features of the embodiments may be combined with each other without conflict. The present application will be described in detail below with reference to the embodiments with reference to the attached drawings.
Fig. 1 shows an extended script-based software breakpoint debugging method of the present invention, which is implemented by a computer, where a compiled language of the present invention: the source code is compiled into a file of machine language before the program is executed, the program does not need to be translated again during running, the compiling result is directly used, and the program execution efficiency is high. Such as C, C + +, etc. The interpreted language of the invention: the program does not need to be compiled in advance and the program code is stored in a text manner. When the program is operated, the interpreter interprets and operates the program line by line, and the program execution efficiency is low. Such as Python, Lua, etc. The method comprises the following steps:
an extended script generating step S101, writing a function of software written by a compiling type language into an extended script for realizing the function by using an interpretation language, and adding a debugging anchor point in the extended script; for example, the software is developed by using a C + + programming language, the extension script is written by using Python, and the software is extended by using the characteristics of an interpreted language, so that the effect of debugging the software function in the running process can be realized. The extension script file is a script file written by a debugger, can be modified in real time from a software interface, and can realize the same or more functions as the software by calling Python API and use the current state and data of the software. That is, the compiled language may be C + +, the interpreted language may be Python, and the debugger may be a Python debugger.
A conversion step S102, converting the link library of the software written by the compiling type language related to the function into a link library which can be called by an interpretation language; in the invention, a Python API is used as an interface which can be called by a script file, and a C + + dynamic link library (Dll) is exported from an interface set and is converted into an pyd format which can be called by Python.
And a debugging step S103, performing breakpoint debugging on the software by the debugger based on the debugging anchor point added in the extension script.
The invention solves the problem that the software debugging method in the prior art is only suitable for the development environment and cannot debug the software in the running process, realizes breakpoint debugging in software running through the extended script, improves the positioning accuracy of software errors, can reproduce software faults and can debug the software in real time, which is an important invention point of the invention.
In one embodiment, the extended script generating step S101 is operated as follows: defining a set of interfaces F ═ { F) for said software 1 ，f 2 ，f 3 ，…，f n-1 ，f n F is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is a function interface of the extended script, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script. The meaning of interface set F means: the fine-grained interface (i.e. API, which may be in the form of dynamic link library. DLL) of software only contains the most basic functions, and is used for combining and calling specific business function modules. The interface functions in the set must be simple and robust enough to reduce errors that may occur.
In the invention, the extended script is directly used for formally replacing some sub-modules of the software, the effect of dynamically debugging the service flow of the sub-modules can be achieved, the problem that the analysis result is static and the step of repeatedly executing the memory DUMP is needed to check the dynamic data to cause the overlarge memory occupation in the prior art is solved, and the method belongs to another important invention point.
In one embodiment, the operation of the converting step S102 is: and converting the link library DLL of the software written by the compiling language C + + related to the function into the link library pyd which can be called by the interpreted language Python.
In one embodiment of the present invention,the operation of the debugging step S103 is: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script waits for external additional debugging at an anchor point X; the Python debugger executes additional debugging, and the code of the extended script is interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When p is greater than p x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
The invention realizes data exchange between C + + and Python, and mutually converts the memory data structure of C + + and the memory data structure of Python, so that the Python can transmit parameters to the C + + interface and read the return result without concerning the difference, thereby realizing synchronous debugging of running software based on the extended script, having small memory occupation and reproducible problem, and being an important invention point of the invention.
Fig. 2 shows an extended script-based software breakpoint debugging device of the present invention, which is installed on a computer, and the compiled language of the present invention: the source code is compiled into a file of machine language before the program is executed, the program does not need to be translated again during running, the compiling result is directly used, and the program execution efficiency is high. Such as C, C + +, etc. The interpreted language of the invention: the program does not need to be compiled in advance and the program code is stored in a text manner. When the program is operated, the interpreter interprets and operates the program line by line, and the program execution efficiency is low. Such as Python, Lua, etc. The device includes:
an extended script generating unit 201, which writes a function of software written in a compiled language using an interpreted language to implement an extended script of the function, and adds a debug anchor in the extended script; for example, the software is developed by using a C + + programming language, the extension script is written by using Python, and the software is extended by using the characteristics of an interpreted language, so that the effect of debugging the software function in the running process can be realized. The extension script file is a script file written by a debugger, can be modified in real time from a software interface, and can realize the same or more functions as the software by calling Python API and use the current state and data of the software. That is, the compiled language may be C + +, the interpreted language may be Python, and the debugger may be a Python debugger.
A conversion unit 202 that converts a link library of software written in a compiled language related to the function into a link library that can be called by an interpreted language; in the invention, a Python API is used as an interface which can be called by a script file, and a C + + dynamic link library (Dll file) is exported from an interface set and is converted into an pyd format which can be called by Python.
And the debugging unit 203 is used for performing breakpoint debugging on the software through a debugger based on the debugging anchor point added in the extension script.
The invention solves the problem that the software debugging method in the prior art is only suitable for the development environment and cannot debug the software in the running process, realizes breakpoint debugging in software running through the extended script, improves the positioning accuracy of software errors, can reproduce software faults and can debug the software in real time, which is an important invention point of the invention.
In one embodiment, the extended script generating unit 201 operates to: defining a set of interfaces F ═ { F) for said software 1 ，f 2 ，f 3 ，…，f n-1 ，f n F is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is a function interface of the extended script, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script. The meaning of interface set F means: fine-grained interfaces (i.e., APIs, which may be in the form of dynamic link libraries. DLLs) for software, contain only the most basic functions forAnd combining and calling the specific service function modules. The interface functions in the set must be simple and robust enough to reduce errors that may occur.
In the invention, the extended script is directly used for formally replacing some sub-modules of the software, the effect of dynamically debugging the service flow of the sub-modules can be achieved, the problem that the analysis result is static and the step of repeatedly executing the memory DUMP is needed to check the dynamic data to cause the overlarge memory occupation in the prior art is solved, and the method belongs to another important invention point.
In one embodiment, the operation of the conversion unit 202 is: and converting the link library DLL of the software written by the compiling language C + + related to the function into the link library pyd which can be called by the interpreted language Python.
In one embodiment, the operation of the debugging unit 203 is: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script waits for external additional debugging at an anchor point X; the Python debugger executes additional debugging, and the code of the extended script is interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When is, p is x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
The invention realizes data exchange between C + + and Python, and mutually converts the memory data structure of C + + and the memory data structure of Python, so that the Python can transmit parameters to the C + + interface and read the return result without concerning the difference, thereby realizing synchronous debugging of running software based on the extension script, having small memory occupation and reproducible problem, and being an important invention point of the invention.
For convenience of description, the above methods are described as being divided into various units by function, and described separately. Of course, the functionality of the units may be implemented in one or more software and/or hardware when implementing the present application.
From the above description of the embodiments, it is clear to those skilled in the art that the present application can be implemented by software plus a necessary general hardware platform. Based on such understanding, the technical solutions of the present application may be essentially or partially implemented in the form of a software product, which may be stored in a storage medium, such as a ROM/RAM, a magnetic disk, an optical disk, etc., and includes several instructions for enabling a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the method according to the embodiments or some parts of the embodiments of the present application.
Finally, it should be noted that: although the present invention has been described in detail with reference to the above embodiments, it should be understood by those skilled in the art that: modifications and equivalents may be made thereto without departing from the spirit and scope of the invention and it is intended to cover in the claims the invention as defined in the appended claims.
Claims (8)
1. A software breakpoint debugging method based on an extended script is characterized by comprising the following steps:
an extended script generating step, namely compiling a function of software compiled by a compiling type language into an extended script for realizing the function by using an interpretation language, and adding a debugging anchor point in the extended script;
a conversion step of converting a link library of software written in a compiling type language related to the function into a link library which can be called by an interpretation language;
debugging, namely performing breakpoint debugging on software by a debugger based on the addition of a debugging anchor point in the extension script, wherein the debugging specifically comprises the following steps: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script is inWaiting for external additional debugging at the anchor point X; the Python debugger executes additional debugging, and the code of the extended script is interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When p is greater than p x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
2. A method according to claim 1, characterized in that: the compiling type language is C + +, the interpretation language is Python, and the debugger is a Python debugger.
3. A method according to claim 2, characterized in that: the operation of the extended script generating step is as follows: defining a set of interfaces F ═ { F) for said software 1 ，f 2 ，f 3 ，…，f n-1 ，f n F is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is a function interface of the extended script, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script.
4. A method according to claim 3, characterized in that: the operation of the converting step is: and converting the link library DLL of the software written in the compiling language C + + related to the function into a link library pyd which can be called by an interpreted language Python.
5. An extended script-based software breakpoint debugging device, characterized in that the device comprises:
the extension script generating unit is used for compiling a function of software compiled by a compiling type language into an extension script for realizing the function by using an interpretation language and adding a debugging anchor point into the extension script;
a conversion unit that converts a link library of software written in a compiled language to which the function relates into a link library that can be called by an interpreted language;
and the debugging unit is used for carrying out breakpoint debugging on the software through a debugger based on the addition of the debugging anchor point in the extension script, and the debugging unit is specifically operated as follows: starting debugging operation on the software interface to open a Python debugger and simultaneously executing the extension script, wherein the extension script waits for external additional debugging at an anchor point X; the Python debugger executes additional debugging, and the code of the extended script is interrupted in the next line of the anchor point X; python debugger steps through single step when executing to function p x When is, p is x Converts the parameters into parameters of C + + and transfers the converted parameters of C + + to the function f x Executing; will function f x The result after execution is converted to Python form by p x And returning and displaying the result of each variable on a Python debugger.
6. The apparatus of claim 5, wherein: the compiling type language is C + +, the interpretation language is Python, and the debugger is a Python debugger.
7. The apparatus of claim 6, wherein: the extended script generating unit executes the following operations: defining a set of interfaces F ═ { F) for said software 1 ，f 2 ，f 3 ，…，f n-1 ，f n F is a fine-grained function interface; interface set P ═ { P ] of extended script 1 ，p 2 ，p 3 ，…，p n-1 ，p n P is a function interface of the extended script, wherein p i And f i Functionally corresponding, i is more than or equal to 1 and less than or equal to n; defining an interface set required by realizing one function of the software as S, wherein the S belongs to P; and compiling an extended script for realizing the function based on the S, and adding a debugging anchor point X at a code entrance of the extended script.
8. The apparatus of claim 7, wherein: the execution operation of the conversion unit is: and converting the link library DLL of the software written by the compiling language C + + related to the function into the link library pyd which can be called by the interpreted language Python.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011599164.2A CN112612712B (en) | 2020-12-29 | 2020-12-29 | Software breakpoint debugging method and device based on extended script |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011599164.2A CN112612712B (en) | 2020-12-29 | 2020-12-29 | Software breakpoint debugging method and device based on extended script |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112612712A CN112612712A (en) | 2021-04-06 |
| CN112612712B true CN112612712B (en) | 2022-08-12 |
Family
ID=75248934
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011599164.2A Active CN112612712B (en) | 2020-12-29 | 2020-12-29 | Software breakpoint debugging method and device based on extended script |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112612712B (en) |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108628739A (en) * | 2018-03-19 | 2018-10-09 | 北京奇艺世纪科技有限公司 | A kind of method that Lua scripts are debugged, client, server and debugger |
Family Cites Families (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8572578B2 (en) * | 2010-06-15 | 2013-10-29 | Microsoft Corporation | Script debugging |
| US9823995B2 (en) * | 2014-08-28 | 2017-11-21 | Sap Se | Structured query language debugger |
| CN104391700A (en) * | 2014-11-11 | 2015-03-04 | 百度在线网络技术（北京）有限公司 | Method and device for expanding functions of application program |
| US9892021B2 (en) * | 2015-03-18 | 2018-02-13 | Sap Se | Injection of code modifications in a two session debug scripting environment |
| CN108255694A (en) * | 2016-12-28 | 2018-07-06 | 比亚迪股份有限公司 | Test method and system based on interpreter |
| CN109189663B (en) * | 2018-07-12 | 2021-10-29 | 武汉精测电子集团股份有限公司 | Plug-in debugging method, plug-in testing method and micro-kernel architecture system |
-
2020
- 2020-12-29 CN CN202011599164.2A patent/CN112612712B/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108628739A (en) * | 2018-03-19 | 2018-10-09 | 北京奇艺世纪科技有限公司 | A kind of method that Lua scripts are debugged, client, server and debugger |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112612712A (en) | 2021-04-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP5415557B2 (en) | User script code conversion for debugging | |
| US6931627B2 (en) | System and method for combinatorial test generation in a compatibility testing environment | |
| US8797338B2 (en) | Platform agnostic screen capture tool | |
| CN115705194A (en) | Code processing method under hardware memory order architecture and corresponding device | |
| US10496423B2 (en) | Method for opening up data and functions of terminal application based on reconstruction technology | |
| US20030226135A1 (en) | Optimized program analysis | |
| US7624381B1 (en) | Portable detection of start and completion of object construction | |
| US11074153B2 (en) | Collecting application state in a runtime environment for reversible debugging | |
| CN113632067A (en) | Emulating non-trace code with recorded execution of trace code | |
| US11113182B2 (en) | Reversible debugging in a runtime environment | |
| US9117017B2 (en) | Debugger with previous version feature | |
| CN109542464B (en) | Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program | |
| CN115525282A (en) | Method for realizing cross-platform desktop application program and related equipment thereof | |
| CN112612712B (en) | Software breakpoint debugging method and device based on extended script | |
| CN111367512B (en) | Method and device for creating Android library module dependency relationship in application development | |
| US20130111432A1 (en) | Validation of a system model including an activity diagram | |
| US6014516A (en) | Language processing system which generates debugging source file corresponding to optimization image and method therefor | |
| CN113641594B (en) | Cross-terminal automatic testing method and related device | |
| CN116775458A (en) | Interface testing method and system for dynamic link library | |
| US20070150866A1 (en) | Displaying parameters associated with call statements | |
| JP2005174045A (en) | Source program conversion device, source program conversion method, source program conversion program and program recording medium | |
| CN112685306A (en) | Test method, test device, user terminal and storage medium | |
| CN110673834A (en) | Source code calling method and device, computer equipment and storage medium | |
| CN111771187B (en) | Method and device for eliminating code construction difference | |
| CN111414301B (en) | Method and device for debugging application program |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |