CN106681897B - Code debugging method and device - Google Patents

Abstract

The invention discloses a code debugging method and a code debugging device, relates to the technical field of computer software programming, and solves the problems of complexity and low efficiency of the conventional Python code debugging process. The main technical scheme of the invention is as follows: acquiring a breakpoint line number set in a code by a user to obtain a breakpoint set; judging whether the current line number is in the breakpoint set or not according to the current line number executed by the code; if so, executing an interrupt event function to interrupt the execution of the code. The method is mainly used for debugging the Python code program.

Description

Code debugging method and device

technical field

The invention relates to the technical field of computer software programming, in particular to a code debugging method and device.

Background technique

IronPython is a .NET implementation of the Python language. With IronPython, .NET developers can provide users with Python code running functions by integrating IronPython in their own software products. For some business functions that require users to customize their own Python code, the emergence of IronPython can be said to be an opportunity for .NET. Developers provide strong technical support.

However, .NET developers will encounter a problem by integrating IronPython in their own software products to provide users with the running function of Python code: when the user finishes writing the Python code that handles specific business and submits it to the software to run Errors in Python code prevent the user's expected business functions from being implemented. At this time, users need to find errors in their own Python code and fix them. By checking the Python code, the user finds suspicious points in several key positions in the code, and hopes that the key positions of the Python code with suspicious points can be suspended during execution to facilitate the user to analyze errors, so as to solve the problems in the code. In the traditional solution, if there is an error in the Python code written by the user, the user usually inserts the pop-up code at the key position of the code to achieve the pause effect when the code runs to the key position, and then the user analyzes the code and the running effect of the code. Determine the location and cause of code errors.

However, although the method of inserting the popup code into the key position of the Python code can also make the Python code pause when it is executed at the key position, there is still a problem with this approach: when the user inserts the popup code into the key position of the Python code , after the Python code runs to the key position where the popup code is inserted and pauses, if the user thinks that there is a certain position behind the key position of the code by analyzing the behavior of the code, he can also pause at a certain position after the execution. When using the traditional method of inserting pop-up code into the code to realize the code running pause effect, the solution can only make the running Python code stop running first, and then the user manually modifies the code to insert the pop-up code into the newly discovered suspicious location and then re-run it. The modified Python code pauses while waiting for the code to run to a suspicious location. This approach is extremely inconvenient for the user to operate, requiring the user to frequently modify the Python code, stop the code from running, re-run the code, and wait for the code to run and pause.

SUMMARY OF THE INVENTION

In view of this, the present invention provides a code debugging method and device, the main purpose of which is to simplify the debugging process of Python code, and quickly determine the position of the problem code by adjusting the position of breakpoints in the code in real time during the debugging process, thereby improving the Python code. debugging efficiency.

To achieve the above object, the present invention mainly provides the following technical solutions:

On the one hand, the present invention provides a code debugging method, the method includes:

Get the breakpoint line number set by the user in the code, and get the breakpoint collection;

According to the current line number of the code execution, determine whether the current line number is in the breakpoint set;

If present, an interrupt event function is executed to interrupt execution of the code.

On the other hand, the present invention also provides a code debugging device, the device includes:

The acquisition unit is used to obtain the breakpoint line number set by the user in the code, and obtain the breakpoint collection;

A judgment unit, for judging whether the current line number is in the breakpoint set obtained by the acquisition unit according to the current line number executed by the code;

An execution unit, configured to execute an interrupt event function to interrupt the execution of the code when the judgment unit judges that the current line number is the breakpoint line number.

According to the code debugging method and device proposed by the present invention, only the user needs to determine the position of the code line that needs to be debugged, and the code program can automatically identify the pause position selected by the user during execution, and stop the code program at this position. Position, wait for the user's next instruction, after receiving the user's instruction to cancel the pause, resume the execution of the code program until it runs to the next debug breakpoint code line. Because the method adopted in the present invention is to update the breakpoint line numbers in the breakpoint set in real time, the breakpoints required by the user can be added or deleted at any time during the execution of the code program, which provides a good solution for the debugging of the code program. More flexible debugging methods. Compared with the existing code program debugging method, the present invention does not require the user to frequently modify the code, and set the insertion pop-up box to suspend the execution of the code program, but the user dynamically selects the position to be suspended during the code debugging process, And restore the running state of the code under the control of the user. Therefore, the code debugging method and device adopted in the present invention can more quickly determine the position of the problem code, thereby improving the debugging efficiency of the Python code.

Description of drawings

Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiments. The drawings are for the purpose of illustrating preferred embodiments only and are not to be considered limiting of the invention. Also, the same components are denoted by the same reference numerals throughout the drawings. In the attached image:

1 shows a flowchart of a code debugging method proposed by an embodiment of the present invention;

FIG. 2 shows a flowchart of another code debugging method proposed by an embodiment of the present invention;

3 shows a block diagram of a code debugging device proposed by an embodiment of the present invention;

FIG. 4 shows a block diagram of another code debugging apparatus provided by an embodiment of the present invention.

Detailed ways

Exemplary embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present invention are shown in the drawings, it should be understood that the present invention may be embodied in various forms and should not be limited by the embodiments set forth herein. Rather, these embodiments are provided so that the present invention will be more thoroughly understood, and will fully convey the scope of the present invention to those skilled in the art.

An embodiment of the present invention provides a code debugging method. As shown in FIG. 1 , the method is applied to a code debugging process of interrupting and stopping code execution, and the specific steps include:

101. Obtain the breakpoint line number set by the user in the code, and obtain a breakpoint set.

In view of the deficiencies of the existing debugging methods, the embodiment of the present invention determines the code lines that need to be suspended when the code is executed by obtaining the breakpoint positions set by the user, and forms the breakpoint sets with these code line numbers. For the breakpoint position set by the user, the user selects the position to be paused in the code in the code editor through the mouse or through the touch screen, and the position may be one or more than one. Moreover, when the user selects the breakpoint location, there is no restriction on the current state of the code. The location of all breakpoints can be determined in advance before execution, or the location of the breakpoint can be determined in real time during the execution of the code. It should be noted that, in the process of code execution, the user can only set the line number of the code line after the current execution line number as the breakpoint position.

Not only that, in the process of setting the breakpoint location, the user also includes two settings: adding a breakpoint to the code and deleting an existing breakpoint. Adding a breakpoint As mentioned above, you can set a breakpoint anywhere in the code, while Deleting a breakpoint is to select the line of code marked with a breakpoint again in the current code marked with a breakpoint to cancel the break mark on this line of code.

The code line numbers of all user-marked interruptions for the code are recorded in the breakpoint collection, and the breakpoint line numbers in the collection are updated in real time. According to the user's choice, the collection will always update the breakpoint line number, add new breakpoints or delete existing breakpoints.

102. According to the current line number of the code execution, determine whether the line number is in the breakpoint set.

After the breakpoint set is created, when debugging the code, each time the code executes a line of code, the line number of the code line will be compared with the breakpoint line number in the breakpoint set to determine whether the line of code is in the Whether to pause after execution. The method for obtaining the current line number of code execution during the execution of the code is not specifically limited in this embodiment. A simpler method is to add a line of code to call the interrupt event function after each line of original code. By building a counter in the calling function To count the number of lines executed by the code, set the initial value of the counter to 1, and add 1 to the counter each time the function is called. By reading the value of the calculator, the current line number of the code execution can be determined.

After the current line number of the code execution is determined, the current line number is brought into the breakpoint set for traversal and matching. If the line number exists in the set, the interrupt event function is executed to suspend the execution state of the code. at the current line; and if the line number does not exist in the set, skip the interrupt event function and continue executing the next line of code.

103. If the current line number is the breakpoint line number, execute the interrupt event function.

After determining that the current line number of the code is the breakpoint line number, the code program will execute the called interrupt event function and suspend the execution state of the code at the current line. The specific implementation manner of the interrupt event function may be a conditional loop function, or a script function, which realizes the pause state by editing the script. This embodiment does not specifically limit the expression manner of the function.

It should be noted that the purpose of suspending the running of the code during the execution process is to allow the debugger to judge the results obtained by the executed program and check whether the executed code is executed according to the expected results. If there is a problem, then You can exit the execution to modify the code, and continue to debug after the modification; if there is no problem, you should be able to resume the execution of the code program and continue to debug the following code. To restore the execution state of the code, it is necessary to jump out of the running interrupt event function. According to the above implementation of the interrupt event function, the user can give an instruction to stop running in the interrupt event function to jump out of the loop execution process of the loop function. Or jump out of the paused state of the script function. Thereby restoring the execution state of the code.

It can be seen in combination with the above implementations that the code debugging method adopted in the embodiment of the present invention only needs the user to determine the position of the code line that needs to be suspended for debugging, and the code program can automatically identify the suspended position selected by the user during execution. And stop the code program at this position, wait for the user's next instruction, and resume the execution of the code program after receiving the user's instruction to cancel the suspension until it runs to the next debug breakpoint code line. Since the method adopted in the embodiment of the present invention is to update the breakpoint line number in the breakpoint set in real time, the breakpoint required by the user can be added or deleted at any time during the execution of the code program, which is the debugging of the code program. Provides a more flexible debugging method. Compared with the existing code program debugging method, the embodiment of the present invention does not require the user to modify the code frequently, and set the insertion pop-up box to suspend the execution of the code program, but the user dynamically selects the code to be suspended during the debugging process of the code. location and restore the running state of the code under user control. Therefore, the code debugging method adopted in the embodiment of the present invention can more quickly determine the position of the problem code, thereby improving the debugging efficiency of the Python code.

In order to describe a code debugging method proposed by the present invention in more detail, the embodiment of the present invention takes the use of Python language to edit a code program, the use of C# language to create a breakpoint set and the above-mentioned interrupt event function as an example for specific description, as shown in FIG. 2 . As shown, the steps included in this method when debugging the code are:

201. Obtain the breakpoint line number set by the user in the Python code, and obtain a breakpoint set.

There are two ways to set the breakpoint line number: one is to select the line number that needs to be interrupted before debugging Python code, and the other is to select the line that needs to be interrupted after the current line of code execution during the debugging process. No. In the specific operation, the user can set a breakpoint by clicking the left button of the mouse at the line number position in the Python code. The selection of the breakpoint can be one or more, for example, a 100-line Python code, the user can Use the left mouse button to click on the 30th, 60th, and 90th lines of code in the code editor, then the line numbers of the 30th, 60th, and 90th lines in the code are determined as breakpoint lines, and the code will be executed when the line is reached. tentatively implemented.

Additionally, these breakpoint line numbers are added to the set of breakpoints created by the C# language. The collection is a collection of integer data that records the line number of the code. There are also two cases for adding the code line number selected by the user to the breakpoint set: one is that the line number does not exist in the breakpoint set, then the line number can be directly added to the set, which is defined as the breakpoint line number The other is that the line number already exists in the breakpoint set, then the line number is cleared from the breakpoint set, which is defined as the delete operation of the breakpoint line number.

202. According to the current line number of the Python code execution, determine whether the line number is in the breakpoint set.

To determine whether the execution line number of the code is the breakpoint line number, a series of preliminary settings are also required. Among them, in addition to obtaining the set of breakpoints mentioned above, it is also necessary to create an instance scriptDebug of the C# script debugging class before debugging, and add an event handler ScriptBreak to the script running interruption event of the instance. Among them, the C# script debugging class scriptDebug code show as below:

Then create an instance scriptDebug of this class, and define a C# function ScriptBreak, and set the script running interrupt event handler of the instance scriptDebug to ScriptBreak. The code is as follows:

scriptDebug.ExecuteBreak=ScriptBreak

In this way, when the instance scriptDebug is called, the C# function ScriptBreak is called.

After that, add the code "scriptDebug.Break()" after each line of the original Python code, so that the added "scriptDebug.Break()" code will be executed when the Python code runs each line, and then the above C# function ScriptBreak will be called. , to implement the interrupt mechanism for Python code.

In addition, in addition to the above settings, a static local variable currentLine=1 needs to be defined inside the C# function ScriptBreak, which represents the line number of the running Python code, and the initial value is 1. Since the code "scirptDebug.Break()" is added after each line of code in the Python code, the C# function ScriptBreak will be called once for each line of Python code execution, and the line number of the Python code execution line number is recorded each time ScriptBreak is called. The variable currentLine value is incremented by 1. Therefore, the current line number executed by the Python code is the value of the variable currentLine. To determine whether the current line number is in the breakpoint set, it is only necessary to traverse whether there is a value of the variable currentLine in the breakpoint set.

203. Use the IronPython scope interface to add the interrupt event function to the scope of the Python code.

Since scriptDebug is a C# instance, if you want to call the scriptDebug method Break in IronPython, you need to add the C# instance scriptDebug to the scope where the Python code runs through the IronPython scope interface SetVariable(name, value).

204. If the current line number is the breakpoint line number, execute the interrupt event function.

When the line number of the running Python code exists in the breakpoint set created by C#, it means that the Python code runs to the breakpoint position, and the execution of the Python code needs to be suspended, that is, the line break event function ScriptBreak. Because the Python code is executed in the IronPython object, and the IronPython object runs in the current thread of the C# program, you only need to write the code that blocks the running of the current thread of C# and let it run. The relevant code is as follows:

while(!continue)

{

}

The initial value of the variable continue in the above code is false, so the while loop will continue to execute, so that the current C# thread is blocked, and the execution of the corresponding Python code running in the IronPython object in the current C# thread will also be suspended.

205. Terminate the execution of the interrupt event function according to the user's instruction, and resume the execution of the Python code.

When you need to continue executing the suspended Python code, you only need to set the value of the variable continue in the C# function to true, then the while(!continue){} loop condition will no longer hold, the loop will exit, and the current C# thread will be released. Blocking, the Python code running in the IronPython object in the current thread of C# can continue to run.

Further, as an implementation of the above method, an embodiment of the present invention provides a code debugging apparatus, and the apparatus embodiment corresponds to the foregoing method embodiment. The detailed contents are described one by one, but it should be clear that the apparatus in this embodiment can correspondingly implement all the contents in the foregoing method embodiments. The device can be set in a code editor with debugging function, as shown in Figure 3, the device includes:

Obtaining unit 31 is used to obtain the breakpoint line number set by the user in the code to obtain a breakpoint set;

Judging unit 32, for judging whether the current line number is in the breakpoint set obtained by the obtaining unit 31 according to the current line number executed by the code;

The execution unit 33 is configured to execute an interrupt event function to interrupt the execution of the code when the judgment unit 32 judges that the current line number is the breakpoint line number.

Further, as shown in FIG. 4 , the obtaining unit 31 includes:

A creation module 311 is used to create a breakpoint set, where the breakpoint line number set by the user in the code is recorded in the breakpoint set;

Obtaining module 312, for obtaining the code line number where the user selects to set the breakpoint position;

The adding module 313 is used to add the code line number obtained by the obtaining module 312 to the breakpoint set created by the creating module 311;

The deletion module 314 is configured to delete the code line number in the breakpoint set created by the creation module 311 when the code line number acquired by the acquiring module 312 already exists in the breakpoint set.

Further, as shown in FIG. 4 , the judging unit 32 includes:

a calling module 321, configured to call the interrupt event function in the interrupt code according to the interrupt code added after each line of the code;

The judgment module 322 is configured to judge whether the current line number of the code execution is in the breakpoint set when the interrupt event function called by the calling module 321 is executed.

Further, the judging module 322 also includes:

Set the sub-module to set the line number counter, and set the initial value to 1;

The calculator is used to add 1 to the value of the counter set by the setting submodule every time the interrupt event function is called when the code is executed to obtain the current line number of the code execution;

The judgment submodule is used to traverse the breakpoint line numbers in the breakpoint set, and judge whether the current line number obtained by the calculation module is the breakpoint line number.

Further, as shown in FIG. 4 , the execution unit 33 includes:

The first execution module 331 is configured to execute the interrupt event function when the code calls the interrupt event function set by the creation module 331, and the current line number of the code execution is the breakpoint line number;

The second execution module 332 is configured to execute the debug interruption script according to the debug interruption script called by the interruption event function executed by the first execution module 331 to interrupt the continued execution of the code.

Further, as shown in Figure 4, the device further includes:

The termination unit 34 is configured to terminate the execution of the interrupt event function executed by the execution unit 33 according to the user's instruction, and resume the execution of the code.

Further, as shown in FIG. 4 , the termination unit 34 includes:

Obtaining module 341, used to obtain the termination instruction of the user;

The stopping module 342 is configured to stop the execution of the interrupt event function according to the termination instruction obtained by the obtaining module, so that the code continues to be executed.

Further, the apparatus uses Python code to edit the code, and uses a C# function to edit the interrupt event function.

Further, as shown in Figure 4, the device further includes:

The adding unit 35 is configured to use the IronPython scope interface to add the interrupt event function to the scope of the code before executing the interrupt event function, where the scope is used to determine the role of the function name in the code scope.

To sum up, the code debugging method and device used in the embodiments of the present invention only need the user to determine the position of the code line that needs to be suspended for debugging, and the code program can automatically identify the suspended position selected by the user when it is executed. The code program stops at this position and waits for the user's next instruction. After receiving the user's instruction to cancel the suspension, the execution of the code program is resumed until it runs to the next debug breakpoint code line. Since the method adopted in the embodiment of the present invention is to update the breakpoint line number in the breakpoint set in real time, the breakpoint required by the user can be added or deleted at any time during the execution of the code program, which is the debugging of the code program. Provides a more flexible debugging method. Compared with the existing code program debugging method, the embodiment of the present invention does not require the user to modify the code frequently, and set the insertion pop-up box to suspend the execution of the code program, but the user dynamically selects the code to be suspended during the debugging process of the code. location and restore the running state of the code under user control. Therefore, the code debugging method and device adopted in the embodiments of the present invention can more quickly determine the location of the problem code, thereby improving the debugging efficiency of the Python code.

The code debugging device includes a processor and a memory, and the above-mentioned acquisition unit, judgment unit, execution unit, and termination unit are all stored in the memory as program units, and the processor executes the above-mentioned program units stored in the memory to realize corresponding functions. .

The processor includes a kernel, and the kernel calls the corresponding program unit from the memory. One or more kernels can be set to simplify the debugging process of Python code by adjusting the kernel parameters, and quickly determine the location of the problem code by adjusting the position of breakpoints in the code in real time during the debugging process, thereby improving the debugging efficiency of Python code.

Memory may include non-persistent memory in computer readable media, random access memory (RAM) and/or non-volatile memory, such as read only memory (ROM) or flash memory (flash RAM), the memory including at least one memory chip.

The present application also provides a computer program product, which, when executed on a data processing device, is suitable for executing a program code initialized with the following method steps: obtaining a breakpoint line number set by a user in the code, and obtaining a breakpoint set; The current line number of the code execution, determine whether the current line number is in the breakpoint set; if there is, execute the interrupt event function to interrupt the execution of the code; terminate the interrupt event according to the user's instruction The execution of the function resumes the execution of the code.

As will be appreciated by those skilled in the art, the embodiments of the present application may be provided as a method, a system, or a computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present application. It will be understood that each flow and/or block in the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to the processor of a general purpose computer, special purpose computer, embedded processor or other programmable data processing device to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing device produce Means for implementing the functions specified in a flow or flow of a flowchart and/or a block or blocks of a block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory result in an article of manufacture comprising instruction means, the instructions The apparatus implements the functions specified in the flow or flow of the flowcharts and/or the block or blocks of the block diagrams.

These computer program instructions can also be loaded on a computer or other programmable data processing device to cause a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process such that The instructions provide steps for implementing the functions specified in the flow or blocks of the flowcharts and/or the block or blocks of the block diagrams.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

Memory may include non-persistent memory in computer readable media, random access memory (RAM) and/or non-volatile memory in the form of, for example, read only memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media includes both persistent and non-permanent, removable and non-removable media, and storage of information may be implemented by any method or technology. Information may be computer readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), Flash Memory or other memory technology, Compact Disc Read Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage, Magnetic tape cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission medium that can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, excludes transitory computer-readable media, such as modulated data signals and carrier waves.

It should also be noted that the terms "comprising", "comprising" or any other variation thereof are intended to encompass a non-exclusive inclusion such that a process, method, article or device comprising a series of elements includes not only those elements, but also Other elements not expressly listed or inherent to such a process, method, article of manufacture or apparatus are also included. Without further limitation, an element qualified by the phrase "comprising a..." does not preclude the presence of additional identical elements in the process, method, article of manufacture or apparatus that includes the element.

It will be appreciated by those skilled in the art that the embodiments of the present application may be provided as a method, a system or a computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The above are merely examples of the present application, and are not intended to limit the present application. Various modifications and variations of this application are possible for those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of this application shall be included within the scope of the claims of this application.

Claims (8)

1. A method for debugging code, the method comprising:

acquiring a breakpoint line number set in a code by a user to obtain a breakpoint set;

judging whether the current line number is in the breakpoint set according to the current line number executed by the code, including: creating an example of a C # script debugging class, adding an interrupt event function to an interrupt event of script running of the example, and calling the interrupt event function in the interrupt code according to the interrupt code added after each line of the code; when the code is executed, adding 1 to the value of a preset line number counter every time the interrupt event function is called, so as to obtain the current line number of the code execution, wherein the initial value of the line number counter is 1; traversing the breakpoint line number in the breakpoint set, and judging whether the current line number is the breakpoint line number;

the creating of an instance of a C # script debugging class and the adding of an interrupt event function to the script running interrupt event of the instance specifically include: creating an instance script debug of a C # script debugging class, setting a script running interrupt event function of the instance script debug as script break, and calling the C # function script break to realize an interrupt mechanism of Python codes when the instance script debug is called;

adding the interrupt event function into the scope of the code by using an IronPython scope interface, wherein the scope is used for determining the scope of the variable in the code, and specifically comprises the following steps: adding the C # instance scriptDebug to the scope of Python code operation through an IronPython scope interface SetVariable (name, value);

if the current thread exists, executing an interrupt event function to interrupt the execution of the code, wherein the interrupt event function is a conditional loop function and is used for blocking the current thread under the running environment in the execution process of the code;

and jumping out of the circular execution process of the interruption event function according to the instruction of the user so as to terminate the operation of the interruption event function and recover the execution of the code.

2. The method of claim 1, wherein obtaining the breakpoint line number set in the code by the user to obtain the breakpoint set comprises:

creating a breakpoint set, wherein a breakpoint line number set in a code by a user is recorded in the breakpoint set;

acquiring a code line number where a user selects to set a breakpoint position;

adding the code line number to the breakpoint set;

deleting the code line number in the breakpoint set when the code line number already exists in the breakpoint set.

3. The method of claim 1, wherein the executing an interrupt event function comprises:

when the code calls the interruption event function and the current line number executed by the code is a breakpoint line number, executing the interruption event function;

and executing the debugging interrupt script according to the debugging interrupt script called by the interrupt event function so as to interrupt the continuous execution of the code.

4. The method of claim 1, wherein terminating execution of the interrupt event function according to the user's instructions comprises:

acquiring a termination instruction of a user;

and stopping the running of the interrupt event function according to the termination instruction so as to enable the code to continue to execute.

5. The method according to any one of claims 1 to 4, wherein the code in the method is edited using Python code and the break event function is a C # function.

6. An apparatus for debugging code, the apparatus comprising:

the acquisition unit is used for acquiring a breakpoint line number set in the code by a user to obtain a breakpoint set;

a judging unit, configured to judge whether the current line number is in the breakpoint set obtained by the obtaining unit according to the current line number executed by the code;

the judging unit includes: a calling module and a judging module;

the calling module is used for creating an example of a C # script debugging class, adding an interrupt event function to an interrupt event of script running of the example, and calling the interrupt event function in the interrupt code according to the interrupt code added after each line of the code;

the creating of an instance of a C # script debugging class and the adding of an interrupt event function to the script running interrupt event of the instance specifically include: creating an instance script debug of a C # script debugging class, setting a script running interrupt event function of the instance script debug as script break, and calling the C # function script break to realize an interrupt mechanism of Python codes when the instance script debug is called;

the judging module is used for judging whether the current line number executed by the code is in the breakpoint set or not when the interruption event function called by the calling module is executed;

the judging module comprises: the device comprises a setting submodule, a calculating submodule and a judging submodule;

the setting submodule is used for setting a line number counter and setting an initial value to be 1;

the computing submodule is used for adding 1 to the value of a counter set by the setting submodule every time the interrupt event function is called during the execution of the code to obtain the current line number of the code execution;

the judgment submodule is used for traversing the breakpoint line number in the breakpoint set and judging whether the current line number obtained by the calculation module is the breakpoint line number;

an adding unit, configured to add, before executing an interrupt event function, the interrupt event function to a scope of the code by using an IronPython scope interface, where the scope is used to determine a scope of a function name in the code, and specifically: adding the C # instance scriptDebug to the scope of Python code operation through an IronPython scope interface SetVariable (name, value);

an execution unit, configured to execute an interrupt event function to interrupt execution of the code when the determination unit determines that the current line number is the breakpoint line number, where the interrupt event function is a conditional loop function and is used to block a current thread in an operating environment in which the code is executed;

and the termination unit is used for jumping out of the circular execution process of the interrupt event function according to the instruction of the user so as to terminate the operation of the interrupt event function and recover the execution of the code.

7. A storage medium, comprising a stored program, wherein when the program runs, a device in which the storage medium is located is controlled to execute the code debugging method according to any one of claims 1 to 5.

8. A processor, configured to execute a program, wherein the program executes the code debugging method according to any one of claims 1 to 5.

Images