KR20150089620A - Method and apparatus for checking data in debugging memory - Google Patents

Abstract

The present invention relates to a method or an apparatus for checking data in a debugging memory. The apparatus for checking data in a debugging memory comprises: a debugging execution unit setting a debugging point for bug correction when a bug occurs in a development application and a memory point where it is necessary to check the data in a debugging memory having data for a development application stored to analyze data copied at the set memory point and selecting a particular plug-in which checks the copied data according to the analysis results, thereby controlling the processing of the data copied within the selected particular plug-in; an application execution unit executing a compiled code of a development application, copying the data at a memory point set by the control of the debugging execution unit when a debugging point is set by the debugging execution unit to transmit the copied data to the debugging execution unit, and then transmitting the copied data to a particular plug-in when the particular plug-in is executed by the debugging execution unit, thereby enabling a developer to check data stored in a debugging memory in real time to more conveniently determine the presence or absence of abnormality of the data stored in a debugging memory.

Description

METHOD AND APPARATUS FOR CHECKING DATA IN DEBUGGING MEMORY BACKGROUND OF THE INVENTION [0001]

The present invention relates to a method for verifying data in a debugging memory and an apparatus therefor. More particularly, the present invention relates to a method for verifying data in a debugging memory by compiling a code for all operations of an application (or a program) To a method for verifying data and to an apparatus therefor.

The contents described in this section merely provide background information on the present embodiment and do not constitute the prior art.

Generally, when a developer develops a program or an application, an error occurs because the developed program is not perfect. Therefore, the developer must find and correct the error of the developed program. The task of finding and fixing errors in these development programs is called debugging, and errors (errors) in programs are called bugs.

There are two methods for debugging: a method using an auxiliary program such as a debugger and a method for detecting an error by inputting data for inspection. In this technique, the debugging is performed by checking the variables used in each logic (code) of the compile code executed by compiling the code for all operations of the program.

In this conventional debugging method, in order to check whether there is an abnormality in data existing in the memory during debugging, a memory is stored as a file, and an application for reprocessing the application is directly executed. .

Therefore, in the conventional debugging method, it is necessary to insert a debugging code to check the data, temporarily store the data in the file system, and develop a separate application to check the data. Therefore, the conventional debugging method has a problem in that the process for checking the data is very complicated and time-consuming, thereby delaying application development.

Published Korean Patent Application No. 2011-0036154, April 07, 2011 (name: application storage server and its operating method)

The present invention has been proposed in order to solve the inconvenience of the prior art, and it is an object of the present invention to provide a method for checking data existing on a debugging memory in real time without a separate debugging code when a bug occurs in a compiled code of a development application executed in an application process And an apparatus therefor.

In addition, the present invention analyzes data copied from a memory location set in the debugging memory in the debugging process, selects and executes a specific plug-in that can check the copied data according to the analysis result, And outputting the data in real time. The present invention also provides a method and apparatus for checking data in a debugging memory.

According to an aspect of the present invention, there is provided a debugging apparatus for setting a debugging point for correcting a bug when a bug occurs in a development application, storing data for the development application, A memory point where data checking is required in the debugging memory, analyzes the copied data at the memory location set in the debugging memory, selects a specific plug-in that can check the copied data according to the analysis result, A debugging execution unit for controlling the debugging execution unit; And a debugging unit for executing the compiled code of the development application. When the debugging execution unit sets the debugging point, the data copying unit copies data copied at the memory location, under control of the debugging execution unit, to the debugging execution unit, And an application execution unit that transmits the copied data to the specific plug-in when the specific plug-in is executed by the debugging execution unit.

The debugging apparatus according to the preferred embodiment of the present invention may further include a storage unit for storing the data for the developed application in the debugging memory, which is a separate storage space allocated to the application executing unit.

In the debugging apparatus according to the preferred embodiment of the present invention, the storage unit stores data on a debugging tool for performing the debugging in a separate storage space allocated to the debugging execution unit, The data copied from the application memory may be stored in a separate storage space allocated to the debugging execution unit.

The debugging apparatus according to the preferred embodiment of the present invention may further include an output unit that outputs an execution screen of the debugging tool of the development application and outputs execution data of the compiled code of the development application executed by the application execution unit, And the like.

In the debugging apparatus according to the preferred embodiment of the present invention, the output unit may output the data processed in the specific plug-in in cooperation with the specific plug-in so that the developer can check the data in real time.

In the debugging apparatus according to the preferred embodiment of the present invention, the debugging execution unit controls the execution of the debugging tool for debugging the development application, generates a debug event when a bug occurs in the compiled code of the currently executed development application Debugging support module; And setting a debugging point for correcting the bug in the currently executed compile code when the debug event occurs, setting a memory point at which data checking is required in the debugging memory, analyzing the copied data at the set memory point, And a debugging process for controlling the selected plug-in to process the copied data by selecting a specific plug-in that can confirm the copied data according to the analysis result.

In the debugging apparatus according to the preferred embodiment of the present invention, the debugging process may include detecting a memory address at a location on a source code included in a debug symbol for the compiled code, setting a debugging point command, To the application executing section.

In the debugging apparatus according to the preferred embodiment of the present invention, the debugging process may set the memory point using a start point and a data size selected by a developer at the set debugging point.

In the debugging apparatus according to the preferred embodiment of the present invention, the debugging process analyzes a header of the copied data, and when the copied data is general data, a registered plug-in corresponding to the analyzed header information is selected Can be executed.

In the debugging apparatus according to the preferred embodiment of the present invention, the debugging processor may analyze the header of the copied data, and may execute a plug-in selected arbitrarily by the developer when the copied data is not general data.

In the debugging apparatus according to the preferred embodiment of the present invention, the application execution unit executes the compiled code of the development application, and when a debugging point is set by the debugging execution unit, An application process of copying data from a point to the debugging execution unit; And one or more plug-ins executed in accordance with the control of the debugging execution unit to read data copied from the memory point of the application execution unit and process the copied data in real time.

According to another aspect of the present invention, there is provided a method for checking data in a debugging memory in a debugging apparatus, the method comprising: executing a compiled code of a development application; Setting a debugging point in the compiled code when a bug occurs in the executed compiled code; Setting a memory location that requires data verification in a debugging memory storing data for the development application; Receiving data copied from a set memory location; Analyzing the copied data and selecting a specific plug-in that can confirm the copied data; Executing the selected specific plug-in; And controlling the copied data to be processed in the specific plug-in executed.

The method of verifying data in a debugging memory in a debugging apparatus according to a preferred embodiment of the present invention may further include the step of selecting a specific plug-in for analyzing the copied data and checking the copied data, Analyzing a header of the data; Checking whether the copied data is general data according to the analysis result; And if the copied data is general data, selecting a registered plug-in corresponding to the analyzed header information.

The method of verifying data in a debugging memory in a debugging apparatus according to a preferred embodiment of the present invention may further include the step of selecting a specific plug-in for analyzing the copied data and checking the copied data, And selecting the plug-in by the developer if the data is not general data.

In the method for checking data in a debugging memory in a debugging apparatus according to a preferred embodiment of the present invention, the step of setting a debugging point in the compiling code may include: when a bug occurs in the executed compiling code, Generating a debug event; Detecting a memory address on the source code using a debug symbol for the compiled code according to a debug event in a debugging process; Setting an instruction of a debugging point using the detected memory address; And transmitting the set debugging point command to an application process for executing the development application.

According to an aspect of the present invention, there is provided a computer-readable recording medium having recorded thereon a program for executing a method for debugging.

According to the present invention, a bug event is generated in a development application (or a program), and the copied data is analyzed by using the selected plug-in through analysis of data copied from a memory point requiring confirmation, thereby outputting the data stored in the debugging memory .

Accordingly, the present invention can more easily confirm the abnormality of data stored in the debugging memory, reduce the time required for application development, and develop applications more accurately.

1 is a block diagram of a debugging apparatus for debugging according to an embodiment of the present invention.
2 is a detailed block diagram of a debugging apparatus for debugging according to an embodiment of the present invention.
3 is a diagram illustrating a method for verifying data in a debugging process memory in a debugging apparatus according to an embodiment of the present invention.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. In the following description and the accompanying drawings, detailed description of well-known functions or constructions that may obscure the subject matter of the present invention will be omitted. It should be noted that the same constituent elements are denoted by the same reference numerals as possible throughout the drawings.

The terms and words used in the present specification and claims should not be construed to be limited to ordinary or dictionary meanings and the inventor is not limited to the concept of terminology for describing his or her invention in the best way. It should be interpreted as meaning and concept consistent with the technical idea of the present invention. Therefore, the embodiments described in the present specification and the configurations shown in the drawings are merely the most preferred embodiments of the present invention, and not all of the technical ideas of the present invention are described. Therefore, It is to be understood that equivalents and modifications are possible.

First, a debugging apparatus for debugging according to an embodiment of the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram of a debugging apparatus for debugging according to an embodiment of the present invention.

1, the debugging apparatus 100 refers to a computing device including an operating system capable of executing various applications and programs, and includes a tablet PC, a laptop, a personal computer (PC) ), A smart phone, a personal digital assistant (PDA), a smart TV, and a mobile communication terminal. In particular, when the debugging apparatus 100 according to the embodiment of the present invention uploads an application or a program developed by the developer, the debugger 100 codes the code for all the operations of the development application or the program, Can be performed. At this time, the debugging apparatus 100 can perform debugging for finding and correcting an erroneous portion in the test code. When the debugging apparatus 100 generates an error in the compiled code, that is, when a debug event occurs, the debugging apparatus 100 can perform debugging through the debugging tool. At this time, the debugging apparatus 100 can set a time required for debugging under a development environment, and can select a memory area that needs confirmation at the time of debugging, using a start point and a data size. Accordingly, the debugging apparatus 100 reads the data stored in the selected memory location, analyzes the header of the data, selects the plugin according to the analyzed header contents, executes the selected plugin, The data copied to memory can be processed. Here, the debugging object may be an application, a program, or the like. Hereinafter, an application will be described as an example in the embodiment of the present invention.

The debugging apparatus 100 may include an input unit 110, a debugging execution unit 120, an application execution unit 130, a storage unit 140, and an output unit 150.

The input unit 110 can generate a developer input signal corresponding to a request or information of the developer according to the operation of the developer. The input unit 110 may be implemented by various input means that are currently commercialized or may be commercialized in the future. For example, the input unit 110 may include general input devices such as a keyboard, a mouse, a joystick, a touch screen, And gesture input means for generating a specific input signal. In particular, the input unit 110 according to the embodiment of the present invention may generate an input signal for information input through the input window of the execution screen of the debugging tool for debugging in cooperation with the debugging execution unit 120. For example, the input unit 110 may receive commands for correcting a bug through an input window of an execution screen, and may generate an input signal corresponding thereto.

When a bug occurs in the development application, the debugging execution unit 120 may set a debugging point for correcting the bug and debug the debugging point using the temporary code for correcting the bug in real time. The debugging execution unit 120 can perform debugging through a debugging tool for debugging, and can operate through a separate process in a central processing unit (CPU) such as a computer.

2, the debugging execution unit 120 includes a debugging support module 121 of a debugging environment composed of a tool for debugging execution, a debugging process for debugging, and a debugging process 122). Here, the debugging process 122 is performed by a central processing unit (CPU) of the debugging apparatus 100, but operates as a separate process. A separate memory is formed in the storage unit 140, Lt; / RTI >

The debugging support module 121 is an operating system such as a Windows kernel or the like that controls the execution of the debugging tool and provides a function for supporting the debugging process 122. [ When the debugging support module 121 generates a debug trap in the application execution unit 130, the debugging support module 121 can detect a debug trap and generate a debug event in the debugging process.

The debugging process 122 is a program that can read and write the memory of the application process 131 executing the development application to be debugged, and performs a function corresponding to the occurrence of the debug event. The debugging process 122 starts the application process 131 or attaches to the application process 131 that is already performed and waits for the generation of the debug event. When the debug event occurs, The process can be repeated using a repeater loop (Debugger loop).

In particular, when a bug occurs, that is, when a debug event occurs, the debugging process 122 can set a debugging point for correcting the bug in the currently executing compiling code, and perform debugging of the set debugging point. Here, the debugging process 122 may detect a memory address at a location on the source code included in the debug symbol for the compiled code, set a debugging point command, and send the set debugging point command to the application executing unit 130.

In addition, when the debugging point is set, the debugging process 122 generates a memory point for data confirmation in the debugging memory storing data (data on the compiled code) for the development application, that is, a compile code (Area) in which data for the application execution unit 130 is stored, and transmits the command signal to the application process 131 of the application execution unit 130. Here, the debugging process 122 can set a memory point at which the confirmation is required at the set debugging point, using the start point and data size selected by the developer.

Accordingly, the debugging process 122 analyzes the header of the copied data after reading the data copied from the designated memory point in the debugging memory, and then analyzes the header of the specific plug-in 132 ) Can be selected. The debugging process 122 may also be coupled to the selected particular plug-in 132 to execute a specific plug-in 132 and to control the executed plug-in 132 to process the data directly read from the memory point. More specifically, in the case where the data existing on the debugging memory in the debugging memory 122 is a data (hereinafter referred to as general data), for example, images such as jpeg, png, waves, etc. The registered plug-in corresponding to the analysis result of the header information of the copied data can be selected. On the other hand, if the copied data is not general data, the debugging process 122 can select and execute a plug-in that can confirm the data by the developer.

Next, the application execution unit 130 executes the development application, that is, executes the compiled code. The application execution unit 130 copies the copied data of the memory point set in the debugging memory storing the data for the developed application to the debugging execution unit 120 ). 2, the application executing unit 130 may include an application process 131 for execution-related processing of an application program and one or more plug-ins 132 . Also, the application execution unit 130 can operate in conjunction with the debugging execution unit 120 in order to check debugging data of the development application and data of the debugging memory in real time. Here, the application process 131 is performed by a central processing unit (CPU) of the debugging apparatus 100, but operates as a separate process. A separate memory is formed in the storage unit 140, Lt; / RTI >

The application process 131 executes the development application, that is, the compiled code in which the developed codes are compiled, and when the debugging point is set by the debugging process 122, the application process 131 receives the command signal from the debugging process 122 . When the application process 131 receives the memory designation command signal from the debugging process 122, the application process 131 may copy the data stored in the debugging memory and provide the copied data to the debugging process 122. When the selected plug-in 132 is executed in the debugging process 122, the copied data can be transmitted to the plug-in 132 in response to the data read request of the selected plug-in 132.

The plug-in 132 is selected in the debugging process 122 and can be executed under the control of the debugging process 122. The plug-in 132 reads the copied data required to be confirmed by the application process 131 in cooperation with the application process 131, On data can be executed. To this end, the plug-in 132 may visualize or audition the copied data, that is, display an image on the plug-in execution screen, or output the sound through the speaker of the output unit 150. Accordingly, the developer can check the presence or absence of data stored in the debugging memory through the data output from the plug-

Also, the plug-in 132 may directly read the result of the 3 ^rd part application stored in the storage unit 140 of the debugging apparatus 100 without reading the data directly from the memory location, but in the form of a temporary file.

The storage unit 140 stores information necessary for the operation of the debugging apparatus 100, and in particular, stores the data for the development application in a debugging memory, which is a separate storage space allocated to the application executing unit 130. The storage unit 140 stores the data of the debugging tool for performing debugging in the debugging execution unit 120 in a separate storage space allocated to the debugging execution unit 120, And may be stored in a separate storage space allocated to the debugging execution unit 120. The storage unit 140 may be an optical storage medium such as a magnetic medium such as a hard disk, a floppy disk and a magnetic tape, a CD-ROM (Compact Disc Read Only Memory), a DVD (Digital Video Disk) A magneto-optical medium such as a floppy disk and a ROM, a random access memory (RAM), and a flash memory.

The output unit 150 is a means for providing the result or state of the operation of the debugging apparatus 100 so that the developer can recognize it. For example, the output unit 150 includes a display unit for visually outputting the result through a screen or a speaker for outputting an audible sound can do. In particular, in the present invention, the output unit 150 may output an execution screen of a debugging tool of a development application to display a screen related to debugging driven by the debugging apparatus 100. [ The output unit 150 outputs the execution data of the compiled code of the development application executed in the application execution unit 130 to the execution screen and outputs the processed data in the specific plug-in 132 in conjunction with the specific plug- can do.

A method for checking the data of the debugging memory in the debugging apparatus constructed as above will now be described in detail with reference to the accompanying drawings.

3 is a diagram illustrating a method for checking data in a debugging memory in a debugging apparatus according to an embodiment of the present invention.

Referring to FIG. 3, in step 1101, the debugging apparatus 100 executes the developed application, that is, the developed compiled code. At this time, when a debug trap occurs in the application process 131 and a debug event is generated by the debugging support module 121, that is, when a bug occurs in the compiled code to be executed, the debugging apparatus 100 performs a debugging process 122) to set the debugging point in the compiled code. At this time, the debugging process 122 detects the memory address on the source code using the debug symbol for the compiled code in accordance with the debug event in the debugging process, sets the command of the debugging point using the detected memory address, And transmits the branch command to the application process for executing the development application.

Accordingly, in step 1103, the debugging apparatus 100 starts debugging at a set debugging point, and performs debugging of the codes through an iterative loop. At this time, the debugging process 120 of the debugging apparatus 100 sets a debugging memory point requiring confirmation at the debugging point, and transmits a memory point setting command signal to the application process 131.

In step 1104, the debugging process 122 of the debugging apparatus 100 reads the data stored in the memory location set in the debugging memory. At this time, the application process 131 copies the data stored in the set memory location and transfers the copied data to the debugging process 122.

In step 1105, the debugging process 122 analyzes the header of the copied data. In step 1106, the debugging process 122 may select a specific plug-in 132 corresponding to the analysis result, that is, the analyzed header information. Then, in step 1107, the specific plug-in 132 selected is executed. Here, the debugging process 122 checks whether the copied data is general data according to the analysis result. If the copied data is general data, the debugging process 122 selects a registered plug-in 132 corresponding to the analyzed header information, If the copied data is not general data, the plug-in 132 is selected by the developer.

Then, the debugging apparatus 100 controls to read and process the data directly copied from the debugging memory through the plug-in 132 to be executed. Accordingly, the plug-in 132 executed in step 1108 directly reads data from the debugging memory. Then, the debugging apparatus 100 visualizes or audibly processes the data read in step 1109 and outputs the data to the debugging apparatus 100 so that the developer can check the data read from the debugging memory, that is, the copied data in real time.

According to the method for debugging, the debugging apparatus 100 receives the changed code, that is, the temporary code, in the debugging operation for testing the application developed by the developer to find the error, inserts the temporary code into the part where the bug occurs, You can test your code. Accordingly, the debugging apparatus 100 can perform a bug correction operation in real time without stopping the debugging and fixing the bug.

On the other hand, the recorded program instructions may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. For example, the recording medium may be an optical recording medium such as a magnetic medium such as a hard disk, a floppy disk and a magnetic tape, a compact disk read only memory (CD-ROM), a digital video disk (DVD) Includes a hardware device that is specially configured to store and execute program instructions such as a magneto-optical medium such as a floppy disk and a ROM, a random access memory (RAM), a flash memory, do. Examples of program instructions may include machine language code such as those generated by a compiler, as well as high-level language code that may be executed by a computer using an interpreter or the like. Such a hardware device may be configured to operate as one or more software modules to perform the operations of the present invention, and vice versa.

Further, a computer program (also known as a program, software, software application, script or code) that is embedded in the apparatus according to the present invention and which implements the method according to the present invention includes a compiled or interpreted language, a priori or procedural language , And may be deployed in any form including standalone programs or modules, components, subroutines, or other units suitable for use in a computer environment. A computer program does not necessarily correspond to a file in the file system. The program may be stored in a single file provided to the requested program, or in multiple interactive files (e.g., a file storing one or more modules, subprograms, or portions of code) (E.g., one or more scripts stored in a markup language document). A computer program may be deployed to run on multiple computers or on one computer, located on a single site or distributed across multiple sites and interconnected by a communications network.

It should be noted that the embodiments of the present invention disclosed in the present specification and drawings are only illustrative of specific examples for the purpose of understanding and are not intended to limit the scope of the present invention. It will be apparent to those skilled in the art that other modifications based on the technical idea of the present invention are possible in addition to the embodiments disclosed herein.

In addition, while the specification contains a number of specific implementation details, it should be understood that they are not to be construed as limitations on the scope of any invention or claim, but rather on the features that may be specific to a particular embodiment of a particular invention Should be understood as an explanation. Certain features described herein in the context of separate embodiments may be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented in multiple embodiments, either individually or in any suitable subcombination. Further, although the features may operate in a particular combination and may be initially described as so claimed, one or more features from the claimed combination may in some cases be excluded from the combination, Or a variant of a subcombination.

Likewise, although the operations are depicted in the drawings in a particular order, it should be understood that such operations must be performed in that particular order or sequential order shown to achieve the desired result, or that all illustrated operations should be performed. Also, the separation of the various system components of the above-described embodiments should not be understood as requiring such separation in all embodiments, and the described program components and systems will generally be integrated together into a single software product or packaged into multiple software products It should be understood.

The present invention relates to a method and an apparatus for debugging, and it is an object of the present invention to provide a method and an apparatus for debugging by outputting copied data using a plug-in selected through analysis of data copied from a memory point requiring confirmation as a bug event occurs in a development application , The developer can check the data stored in the debugging memory in real time.

Accordingly, the present invention can more easily confirm the abnormality of data stored in the debugging memory, reduce the time required for application development, and develop applications more accurately.

In addition, the present invention has a possibility of commercial use or business, and is industrially applicable because it is practically possible to carry out clearly.

100: debugging apparatus 110: input unit 120: debugging execution unit
121: Debugging support module 122: Debugging process
130: Application execution unit 131: Application process
132: plug-in 140: storage unit 150: output unit

Claims (16)

When a bug occurs in a development application, a debugging point for correcting a bug is set, a memory point for checking data is set in a debugging memory storing data for the development application, A debugging execution unit for selecting a specific plug-in that can check the copied data according to the analysis result, and controlling the selected copied plug-in to process the copied data; And
Wherein the debugging unit executes the compiled code of the development application, and when the debugging execution unit sets the debugging point, the data copying unit copies the copied data at the memory location according to the control of the debugging execution unit and transmits the copied data to the debugging execution unit, An application execution unit for transmitting the copied data to the specific plug-in when the specific plug-in is executed by the debugging execution unit;
And a debugging unit for debugging the debugging apparatus. The method according to claim 1,
A storage unit for storing data for the development application in the debugging memory, which is a separate storage space allocated to the application execution unit;
Further comprising: a debugging unit operable to debug the debugging device. The apparatus according to claim 2,
Wherein the debugging unit stores data for a debugging tool for performing debugging in a separate storage space allocated to the debugging execution unit, and the data copied from the application memory in the debugging execution unit is stored in a separate storage And stores the program in a space. The method according to claim 1,
An output unit outputting an execution screen of a debugging tool of the development application and outputting execution data of a compiled code of the development application executed by the application executing unit to the execution screen;
Further comprising: a debugging unit operable to debug the debugging device. 5. The apparatus according to claim 4,
Wherein the debugging unit outputs the data processed by the specific plug-in in cooperation with the specific plug-in so that the developer can check the data processed in real time. The apparatus of claim 1, wherein the debugging execution unit comprises:
A debugging support module for controlling the execution of the debugging tool for debugging the development application and generating a debug event when a bug occurs in the compiled code of the currently executed development application; And
Setting a debugging point for correcting the bug in a currently executing compile code, setting a memory point for which data checking is required in the debugging memory, analyzing data copied from the memory point, A debugging process of selecting a specific plug-in that can check the copied data according to the analysis result and controlling the selected copied plug-in to process the copied data;
And a debugging unit for debugging the debugging apparatus. 7. The method of claim 6,
Detecting a memory address at a location on the source code included in the debug symbol for the compiled code, setting a debugging point command, and transmitting the set debugging point command to the application executing unit. 7. The method of claim 6,
Wherein the memory location is set using a starting point and a data size selected by a developer at the set debugging point. 7. The method of claim 6,
Analyzing a header of the copied data, and, when the copied data is general data, selecting a registered plug-in corresponding to the analyzed header information, and executing the selected plug-in. 7. The system of claim 6, wherein the debugging processor comprises:
And analyzes the header of the copied data to execute a plug-in selected arbitrarily by the developer if the copied data is not general data. The apparatus according to claim 1,
An application process of executing the compiled code of the development application and copying data to the debugging execution unit according to a control of the debugging execution unit when the debugging execution unit sets a debugging point; And
One or more plug-ins executed under the control of the debugging execution unit to read data copied from the memory point of the application execution unit and process the copied data in real time;
And a debugging unit for debugging the debugging apparatus. Executing the compiled code of the development application;
Setting a debugging point in the compiled code when a bug occurs in the executed compiled code;
Setting a memory location that requires data verification in a debugging memory storing data for the development application;
Receiving data copied from a set memory location;
Analyzing the copied data and selecting a specific plug-in that can confirm the copied data;
Executing the selected specific plug-in; And
Controlling to process the copied data in a specific plug-in executed;
The method of claim 1, further comprising the steps of: The method of claim 12, wherein the step of selecting a particular plug-in, which is capable of analyzing the copied data and confirming the copied data,
Analyzing a header of the copied data;
Checking whether the copied data is general data according to the analysis result; And
If the copied data is general data, selecting a registered plug-in corresponding to the analyzed header information;
The method of claim 1, further comprising the steps of: The method of claim 13, wherein the step of selecting a particular plug-in, which can analyze the copied data and check the copied data,
Selecting the plug-in by the developer if the copied data is not general data;
Further comprising the steps of: receiving the debugging data from the debugging memory. 13. The method of claim 12, wherein the step of setting a debugging point in the compiled code comprises:
Generating a debug event in the real-time support module when a bug occurs in the executed compile code;
Detecting a memory address on the source code using a debug symbol for the compiled code according to a debug event in a debugging process;
Setting an instruction of a debugging point using the detected memory address; And
Transmitting a set debugging point command to an application process for executing the development application;
The method of claim 1, further comprising the steps of: A computer readable recording medium storing a program for executing a method for verifying data of the debugging memory according to any one of claims 12 to 15.

Images