CN106681897A - Code debugging method and device - Google Patents

Abstract

The invention discloses a code debugging method and device, relates to the technical field of computer software programming, and solves the problems that an existing Python code is complicated in debugging process and low in debugging efficiency. The technical scheme includes the code debugging method includes the steps: acquiring a breakpoint row number set in a code by a user to obtain a breakpoint set; judging whether a current row number is in the breakpoint set or not according to the current row number executed by the code; executing an interrupt event function if the current row number is in the breakpoint set, and interrupting execution of the code. The code debugging method is mainly used for debugging Python code procedures.

Description

A 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 integrate IronPython in their software products to provide users with the running function of Python code. For some business functions that need to be customized by users through Python code, the appearance of IronPython can be said to be for .NET Developers provide strong technical support.

However, .NET developers will encounter a problem in providing users with the function of running Python codes by integrating IronPython in their software products: when users write Python codes that handle specific businesses and submit them to the software for running, they may fail because of the written Python code. An error in the Python code prevents the user's expected business function from being realized. At this time, the user needs to find the error in the Python code written by the user and correct it. The user finds suspicious points in several key positions in the code by checking the Python code, and hopes that the execution of several key positions in the Python code with suspicious points can be paused to facilitate the user to analyze errors, so as to solve the problems existing 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 realize 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 to find out Determine the location and cause of the code error.

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

Contents 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 breakpoint position in the code in real time during the debugging process, thereby improving the Python code. debugging efficiency.

In order to achieve the above object, the present invention mainly provides the following technical solutions:

On the one hand, the present invention provides a kind of code debugging method, and this method comprises:

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

judging whether the current line number is in the breakpoint set according to the current line number executed by the code;

If it exists, execute the interrupt event function to interrupt the execution of the code.

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

The obtaining unit is used to obtain the line number of the breakpoint set by the user in the code, and obtain the set of breakpoints;

a judging unit, configured to judge 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 judging 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, the user only needs to determine the position of the code line that needs to be suspended for debugging, and the code program can automatically recognize the pause position selected by the user when the code program is executed, and stop the code program at this position. At the position, wait for the user's next instruction, and after receiving the user's instruction to cancel the suspension, resume the execution of the code program until it runs to the next debugging breakpoint code line. Because the method adopted by the present invention is to update the breakpoint line number in the breakpoint collection in real time, therefore, the breakpoint required by the user can be added or deleted at any time during the execution of the code program, which provides a great advantage 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 bullet box to suspend the execution of the code program. Instead, the user dynamically selects the position that needs 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 location of problem codes, thereby improving the debugging efficiency of Python codes.

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 embodiment. The drawings are only for the purpose of illustrating a preferred embodiment and are not to be considered as limiting the invention. Also throughout the drawings, the same reference numerals are used to designate the same components. In the attached picture:

Fig. 1 shows a flow chart 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;

FIG. 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 device proposed by an embodiment of the present invention.

detailed description

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

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

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

To address the shortcomings of the existing debugging methods, the embodiment of the present invention determines the code lines that need to be suspended during code execution by obtaining the breakpoint positions set by the user, and forms these code line numbers into a breakpoint set. For the breakpoint position set by the user, the user selects the position in the code that needs to be paused in the code editor through the mouse or through the touch screen, and the position can be one or multiple. Moreover, when the user selects the breakpoint position, there is no limit to the current state of the code. The position of all breakpoints can be determined in advance before execution, or the position of the breakpoint can be determined in real time during the execution of the code. It should be noted that during code execution, the user can only set the code line number after the current execution line number as the breakpoint position.

Not only that, in the process of setting the breakpoint position, the user also includes two settings for adding a breakpoint and deleting an existing breakpoint in the code. Adding a breakpoint as mentioned above can set a breakpoint at any position in the code, To delete a breakpoint is to select the code line marked with a breakpoint again in the current code marked with a breakpoint to cancel the break mark on the code line.

The breakpoint collection records the code line numbers that all users mark breaks for the code, and the breakpoint line numbers in the collection are updated in real time. According to the user's choice, the collection will update the breakpoint line number, add new breakpoints or delete existing breakpoints.

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

After creating a breakpoint set, when debugging the code, each time the code executes a line of code, it will compare the line number of the code line with the breakpoint line number in the breakpoint set to determine whether the line of code is Whether to pause after execution. This embodiment does not specifically limit the method of obtaining the current line number of code execution during code execution. The simpler method is to add a call interrupt event function code after each line of original code, and build a counter in the call function To count the number of lines of code execution, set the initial value of the counter to 1, add 1 to the counter every time the function is called, and determine the current line number of code execution by reading the value of the calculator.

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

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

When the current line number of the code is determined to be the breakpoint line number, the code program will execute the interrupt event function called, and suspend the execution state of the code at the current line. The specific implementation of the interrupt event function may be a conditional loop function, or a script function, and the pause state is realized by editing the script. This embodiment does not specifically limit the performance of the function.

It should be noted that the purpose of suspending the code during execution is to allow debuggers to judge the results obtained by the executed program and check whether the executed code is executing according to the expected results. If there is a problem, then You can exit the execution to modify the code, and continue debugging 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 implementation method of the above 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 break out of the paused state of a script function. This restores the execution state of the code.

In combination with the above-mentioned implementation methods, it can be seen 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 suspend debugging, and the code program can automatically recognize the suspend position selected by the user when it is executed. 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 debugging breakpoint code line. Because the method adopted in the embodiment of the present invention is to update the breakpoint line number in the breakpoint set in real time, therefore, the breakpoint required by the user can be added or deleted at any time during the execution of the code program, which is helpful for 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 bullet box to suspend the execution of the code program, but the user dynamically selects the program that needs to be suspended during the code debugging process. 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 location of the problem code, thereby improving the debugging efficiency of the Python code.

In order to illustrate a kind of code debugging method that the present invention proposes in more detail, the embodiment of the present invention uses Python language to edit the code program, utilizes C# language to create breakpoint set and above-mentioned interrupt event function as examples, as shown in Figure 2 As shown, the steps included in this method when debugging the code are:

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

There are two ways to set the breakpoint line number: one is to select the line number that needs to be interrupted before debugging the 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 terms of specific operations, the user can set a breakpoint by clicking the line number position in the Python code with the left button of the mouse. The choice of the breakpoint can be one or more. For example, for a 100-line Python code, the user can In the code editor, click the 30th, 60th, and 90th line of code with the left button of the mouse, and the line number of the 30th, 60th, and 90th line in the code will be determined as the breakpoint line, and the code will be executed when it reaches this line. Tentative implementation.

In addition, these breakpoint line numbers will also be added to the set of breakpoints created by the C# language. This collection is a collection of integer data, which records the line number of the code. There are two cases of adding the code line number selected by the user to the breakpoint collection: one is that the line number does not exist in the breakpoint collection, then the line number can be directly added to the collection, 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 executed by the Python code, determine whether the line number is in the breakpoint set.

To determine whether the execution line number of the code is a breakpoint line number, a series of preliminary settings are also required. Among them, in addition to the above-mentioned collection of breakpoints, it is also necessary to create an instance scriptDebug of the C# script debugging class before debugging, and add an event processing function ScriptBreak to the script running interruption event of this instance, wherein, 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 execution interruption event processing function of the instance scriptDebug as ScriptBreak, the code is as follows:

scriptDebug.ExecuteBreak = ScriptBreak

In this way, when the instance scriptDebug is called, the C# function ScriptBreak will be 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 every time the Python code runs, and then call the above-mentioned C# function ScriptBreak , 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, representing the line number of the running Python code, with an initial value of 1. Since the code "scirptDebug.Break()" is added after each line of the Python code, the C# function ScriptBreak will be called once every time the Python code is executed, and the Python code execution line number will be recorded every time ScriptBreak is called. The value of the variable currentLine will increase by 1. Therefore, the current line number of Python code execution is the value of the variable currentLine. To determine whether the current line number is in the breakpoint set, you only need to traverse the breakpoint set to see if there is the value of the variable currentLine.

203. Using 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 line number of the breakpoint, 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 has run to the breakpoint position, and the running 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 C# current thread to 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 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 to execute the paused 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 be true, and the loop will exit, so that 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 the implementation of the above method, the embodiment of the present invention provides a code debugging device, the device embodiment corresponds to the foregoing method embodiment, for the convenience of reading, this device embodiment does not refer to the foregoing method embodiment The details will be described one by one, but it should be clear that the device in this embodiment can correspondingly implement all the content in the foregoing method embodiments. The device can be set in the code editor with debugging function, as shown in Figure 3, the device includes:

An acquisition unit 31, configured to acquire the line number of the breakpoint set by the user in the code, to obtain a set of breakpoints;

A judging unit 32, configured to judge whether the current line number is in the breakpoint set obtained by the acquiring 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 judging unit 32 judges that the current line number is the breakpoint line number.

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

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

An acquisition module 312, configured to acquire the code line number where the user chooses to set the breakpoint position;

An adding module 313, configured 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 from the breakpoint set created by the creation module 311 when the code line number acquired by the acquisition 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 judging 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 submodule, which is used to set the line number counter, and set the initial value to 1;

The calculation sub-module is used to add 1 to the value of the counter set by the setting sub-module every time the interrupt event function is called when the code is executed, so as to obtain the current line number of the code execution;

The judging sub-module is used for traversing the breakpoint line numbers in the breakpoint set, and judging whether the current line number obtained by the calculation module is a 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 executed by the code is a breakpoint line number;

The second execution module 332 is configured to execute the debugging interruption script according to the debugging interruption script called by the interruption event function executed by the first execution module 331, so as to interrupt the continuous execution of the code.

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

The termination unit 34 is configured to terminate the operation 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:

An acquisition module 341, configured to acquire a user termination instruction;

The stop module 342 is configured to stop the execution of the interrupt event function according to the termination instruction acquired by the acquisition module, so that the code can continue to execute.

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

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

The adding unit 35 is used to add the interrupt event function to the scope of the code by using the IronPython scope interface before executing the interrupt event function, and the scope is used to determine the function of the function name in the code scope.

In summary, the code debugging method and device adopted 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 recognize the pause position selected by the user when it is executed, and The code program stops at this position, waiting for the user's next instruction, and after receiving the user's instruction to cancel the suspension, resumes the execution of the code program until it runs to the next debugging breakpoint code line. Because the method adopted in the embodiment of the present invention is to update the breakpoint line number in the breakpoint set in real time, therefore, the breakpoint required by the user can be added or deleted at any time during the execution of the code program, which is helpful for 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 bullet box to suspend the execution of the code program, but the user dynamically selects the program that needs to be suspended during the code debugging process. 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 problem codes, thereby improving the debugging efficiency of Python codes.

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

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

Memory may include non-permanent memory in computer-readable media, random access memory (RAM) and/or non-volatile memory, such as read-only memory (ROM) or flash memory (flashRAM), and memory includes at least one storage 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 that is initialized with the following method steps: obtain the breakpoint line number set by the user in the code, and obtain a breakpoint set; The current line number of the code execution, judge whether the current line number is in the breakpoint set; if it exists, 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 execution of the code.

Those skilled in the art should understand that the embodiments of the present application may be provided as methods, systems, or computer program products. 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 flowcharts and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present application. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the 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 operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart 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-permanent storage in computer readable media, in the form of random access memory (RAM) and/or nonvolatile memory, such as read only memory (ROM) or flash RAM. The memory is an example of a computer readable medium.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. Information may be computer readable instructions, data structures, modules of a program, 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 cartridge, tape magnetic disk storage or other magnetic storage device or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media excludes transitory computer-readable media, such as modulated data signals and carrier waves.

It should also be noted that the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article, or apparatus comprising a set of elements includes not only those elements, but also includes Other elements not expressly listed, or elements inherent in the process, method, commodity, or apparatus are also included. Without further limitations, an element defined by the phrase "comprising a ..." does not preclude the presence of additional identical elements in the process, method, article, or apparatus that includes the element.

Those skilled in the art should understand that the embodiments of the present application may be provided as methods, systems or computer program products. Accordingly, the present application can 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 only examples of the present application, and are not intended to limit the present application. For those skilled in the art, various modifications and changes may occur in this application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims (10)

1. A code debugging method, characterized in that the method comprises: Get the breakpoint line number set by the user in the code, and get the breakpoint set; judging whether the current line number is in the breakpoint set according to the current line number executed by the code; If it exists, execute the interrupt event function to interrupt the execution of the code. 2. The method according to claim 1, wherein said obtaining the breakpoint line number set by the user in the code and obtaining the breakpoint set comprises: Create a breakpoint set, which records the breakpoint line number set by the user in the code; Obtain the code line number where the user chooses to set the breakpoint location; adding the code line number to the set of breakpoints; When the code line number already exists in the breakpoint set, delete the code line number in the breakpoint set. 3. The method according to claim 1, wherein, according to the current line number executed by the code, it is judged whether the current line number includes in the breakpoint set: calling the interrupt event function in the interrupt code according to the interrupt code added after each line of the code; When executing the interrupt event function, it is judged whether the current line number executed by the code is in the breakpoint set. 4. The method according to claim 3, wherein the judging whether the current line number of the code execution is included in the breakpoint set includes: Set the line number counter and set the initial value to 1; When the code is executed, every time the interrupt event function is called, the value of the counter is added by 1 to obtain the current line number of the code execution; Traverse the breakpoint line numbers in the breakpoint set, and judge whether the current line number is the breakpoint line number. 5. The method according to claim 4, wherein the execution interrupt event function comprises: When the code calls the interrupt event function, and the current line number executed by the code is the breakpoint line number, execute the interrupt event function; Execute the debug interrupt script according to the debug interrupt script invoked by the interrupt event function, so as to interrupt the continued execution of the code. 6. The method according to claim 1, further comprising: The execution of the interrupt event function is terminated according to the user's instruction, and the execution of the code is resumed. 7. The method according to claim 6, wherein the terminating the execution of the interrupt event function according to the user's instruction comprises: Obtain the user's termination instruction; The execution of the interrupt event function is stopped according to the termination instruction, so that the code continues to execute. 8. The method according to any one of claims 1-7, wherein the code in the method is edited using Python code, and the interrupt event function is a C# function. 9. The method according to claim 8, wherein, before executing the interrupt event function, the method further comprises: The interrupt event function is added to the scope of the code by using the IronPython scope interface, and the scope is to determine the scope of the variables in the code. 10. A code debugging device, characterized in that the device comprises: The obtaining unit is used to obtain the line number of the breakpoint set by the user in the code, and obtain the set of breakpoints; a judging unit, configured to judge 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 judging unit judges that the current line number is the breakpoint line number.