KR940008474B1 - Debugging system and control method of program developing apparatus - Google Patents

Abstract

The control method calls directly functional execution tools in a user environment area for the purpose of efficiency of a debugger system. The control method contains an input tool (10), a microprocessor (20) for execution of an operating system and functional execution tools, a memory (30), an output tool (40), a step for registering the necessary information to call a functional execution tool, a step to make a batch file for execution of a functional execution tool, and a step for direct execution of a functional tool.

Description

Debugger Control Method of Program Development Device

1 is a hardware block diagram of a debugger system to which the present invention is applied.

FIG. 2 is a cross section showing the function performing means allocated in the memory of FIG.

3 is a flowchart showing the performance of the present invention.

* Explanation of symbols for main parts of the drawings

10: input unit 20: microprocessor

30: storage unit 40: output unit

100: debugger system 200: target

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugger control method of a program development apparatus. Specifically, the present invention relates to a user environment registration area of a debugger system using a debugger system of a program development apparatus for designing a program to be executed on a specific microprocessor. The present invention relates to a control method of a debugger system for directly invoking various function performing means.

The conventional debugger system is operated in a separate step from the means for performing functions, such as a document editor, a linker, a compiler, and a batch processing device, which are operated in conjunction with the debugger system.

That is, when the debugger system intends to operate at least one of the function performing means, the function performing means on the user interface using a user interface of an operating system (cperating system) mounted in a computer as a medium for performing the function. There was a problem that the function of such a debugger is lowered because it operates.

Mechanically, the conventional debugger system performs the operation through an input device such as a keyboard when operating the function performing means or the like during the execution of the system.

In this case, the user first proceeds to the user interface of the operating system, and then operates the function performing means in this user interface by means of several key inputs.

As such, the conventional debugger system does not operate the function performing means by itself, and enters the user interface of the operating system and operates the function performing means, so that many key input devices need to be operated to operate them. In addition, it takes a lot of time because the keys are operated according to key input and many key operations are also required to return back to the debugger system, and also because the means are operated on a separate medium, the batching of debugging work is performed. This disappearing problem also occurred.

In order to solve the above problems, the present invention can directly operate the function performing means in the debugging process without proceeding the debugging process to the user interface stage, which is an operating system, when the function performing means is to be operated during debugging. The purpose is to provide a debugger control method of a program development apparatus.

According to an aspect of the present invention for achieving the above object, the debugging control method is to execute the operating system and the overall function performing means having an input means for inputting data, a user interface installed for smooth use between the user and the system A microprocessor, a memory storing the operating system and the function performing means, well-known debugging means for detecting an error of a program, an output means for outputting predetermined data according to the execution of the microprocessor, and a user environment registration means. A computer system comprising: registering information for executing at least one function performing means in a function performing means including a document editor, a linker, a compiler, and a user batch file in a user environment registration area of the user environment registration means. Step, and the environment registration in the debugging means A debugging control comprising a step of making a batch file for making use of at least one function performing means registered in the means, and directly executing the function performing means registered in the user environment registration means in the operation stage of the private debugger means; Method.

In the above description, the user batch file executes the compiler and the linker in order, and the user creates the file using a known text editor.

Batch files mean that the debugger makes itself to run the means of functioning.

Hereinafter, preferred embodiments of the present invention will be described in detail.

1 is a block diagram schematically illustrating a hardware environment for supporting a debugger system according to the present invention.

In FIG. 1, reference numeral 100 denotes a debugger system of the present invention, and is a device for supporting program development which detects an error while executing a program created by a user, corrects the error, and executes the same.

The debugger system 100 includes an input unit 10 for inputting general data and function control data, an operating system including a user interface that is a tool for allowing a user of the system to use the system smoothly, a plurality of means for performing a function, and a user. A storage unit 30, which is a memory for storing an error of a created program, including debugging means for correcting and executing the program, and a micro for calling and executing the plurality of function performing means while executing the program. A processor 20 and an output unit 40 for displaying or printing out the processing result of the microprocessor 20 are included.

Reference numeral 200 is an apparatus for receiving a program for a microprocessor provided from the debugger system 100 as a target.

Reference numeral 300 is a communication line connected between the debugger system 110 and the target 200 to transmit and receive an executable file and data.

In the memory unit 30, which is the memory, as shown in FIG. 2, a user environment registration area is set. In this area, for document editing, linker, and compiler, which can be executed in conjunction with the execution of the debugging means. Information that executes programs, user batch files, and the like is stored.

The user environment area may be stored in the memory 30 as shown in FIG. 2, but the memory may be stored as when the computer system is powered off, or when the current program is debugged and the next time the next program is debugged. A user environment area may be set in the auxiliary memory device in case the information of 30 is destroyed.

In addition, during the debugging operation, the storage unit 30 and the auxiliary storage device are used to use the user environment area of the storage unit 30, which has a high speed of information movement, and to use the auxiliary storage device when the contents of the storage unit 30 are destroyed. You can also set the user environment area in duplicate.

If the function execution means is a function execution program that can be operated in conjunction with the debugging means in addition to the above-described programs, the execution information is registered in the user environment area so that it can be referred at any time during the execution of the debugging means.

As described above, in order to execute a plurality of function execution programs or batch files registered in the user environment registration area during the execution of the debugging means, the debugging means may directly execute the function means.

For example, you need to use a text editing program when you need to create a new source file while running a debugging tool, or when you need to modify an error-detected source file.

At this time, if the debugger selects a specific window, a section for executing the document editing program appears. If the item is selected, the document editing program can be executed even while the debugger is running.

For example, there are several ways that a debugger can run a text editor program.

First, there is a method of executing the debugger execution processor as a parent process and executing a document editing program registered in the debugger's environment registration area as a child process. Second, registering the debugger execution process in the user environment registration area of the debugger. There is a method of creating a batch file that can be executed on the user interface of the operating system using the document editing program name, and then calling the operating system user interface.

In this way, by enabling the debugger means to execute the document editor program registered in the user environment registration area, the document editing program can be executed by a simple key input operation of the input unit 10 in the execution step of the debugger means.

In the above example, the process of executing the debugger means by calling the document editor among the function performing means registered in the user environment registration area has been described. However, the process of directly processing the compiler, the linker and the batch processing means in the execution step of the debugger means is described above. Is the same as

The only difference is the selection of the different means for performing the functions displayed on the window.

As described above, in order to execute the execution file registered in the user environment registration area in the execution step of the debugger means, the user environment registration means for registering the function execution means associated with the debugger means and the specific selection item displayed on the window may be selected. In this case, a process of executing the execution program registered in the user environment area by the user environment registration means is required.

On the other hand, if you want to compile the source file while executing the debugger means, select the specific item displayed on the window of the debugger, and the name of the source file that was compiled last appears, and if you want to compile the file immediately Compiler registered in the user environment can be executed and the file can be compiled immediately.If you want to compile a new file, you can enter a new file name and compile it with the compiler registered in the user environment. .

In addition, if you want to link the target files, select a specific item on this debugger, and you will get the option for the linker when you last used the linker registered in the user environment area. If you want to run a linker that has been registered in the user environment zone according to the specification, just hit enter to run the linker. If you want to run a linker that has been registered in the user environment zone as another option, use the new option for that linker. If you give it and run the linker, it will run according to the new specifications.

In addition, when you want to batch compile and linker work using the compiler and linker registered in the user environment registration column, select the specific item displayed on the window of the debugger system, and then the user batch registered in the user environment registration area. The processing file is executed to batch compile and linker tasks.

In summary, any compiler designed for a microprocessor in any debugger running on a development computer that is attached to a device used to design a program that runs on a particular microprocessor, and the purpose of compiling it with any compiler. Register any linker that can link the file, any text editor, and batch file that can run the compiler and linker in this order in the user environment registration area that sets the execution environment of the debugger. .

When executing the executable files at the time of execution of the debugger, the debugger executes these executable programs as a self-processor or by executing a batch file created using these executable files by calling the operating system user interface, This can reduce the number of keyboard errors that can occur when a debugger user runs these executables directly on the operating system's user interface, and improves program development efficiency by maintaining consistent application debugging.

3 is an overall flowchart of the present invention. After the debugger is executed (step S2), it is determined whether to change the registered items of the user environment registration area (step S3).

If there is an item to be changed (step S4), each item in the user environment registration area including a document editor name, a compiled name, a linker name, a user batch file name, and the like is changed.

At this time, the name of the document editor, compiler name, linker name, user batch file name, etc. changed and registered must exist somewhere in the storage medium that can be used by the development computer and be always available. This condition must be available in the environment file of the debugger. This is always applied when registering a change.

If it is necessary to execute the text editor during debugging (step S5), and if it is not necessary, the process proceeds to step S33.

If it is necessary to execute the text editor, it is decided whether or not to execute the text editor registered in the user environment registration area (step S6), and if the document editor registered in the user environment registration area is used, the document editor program can be executed. The specific item on the debugger to be selected is selected and executed (step S9).

Otherwise, it is determined whether to change the name of the document editor in the user environment registration area and register it (step S7). To do so, register the document editor name in the user environment registration area with another document editor name and register it (step S8). Run

If the determination in step S7 is No, then it is determined whether to terminate the use of the debugger for execution of a text editor program or for other purposes (step S11), and to finish the use of the debugger (step S37), otherwise the operating system The user interface of the user interface is called, and then the document editor is executed or another operation is performed on the user interface of the operating system (step S12).

After executing the above steps S9 and S12, it is determined whether or not the compiler needs to be executed (step S10). If there is no need for execution, the process proceeds to the next step S33. Otherwise, it is determined whether to execute the compiler registered in the user environment registration column. If it is necessary to determine (step S13), execution goes to the next step S18.

If the compiler is not executed in step S13, it is determined whether or not the compiler registered in the user environment registration column is changed to another compiler and then executed (step S14). If it is not executed, the debugger is used to execute the compiler or for other purposes. It is determined whether or not to end the process (step S15).

If the determination of step S15 is YES, then the use of the debugger is terminated (step S37); otherwise, the user interface of the operating system is called, and then the compiler is run or another operation is performed on the operating system user interface (step S16). Run S19.

On the other hand, if " Yes " in step S14, the compiler in the user environment registration column is changed to another compiler and registered (step S17).

After executing step S17, a specific item on the debugger that enables the compiler to be selected is selected to execute the compiler (step S18).

After executing the compiler in step S18, it is determined whether the linker needs to be executed during debugging (step S19), and when no execution is necessary, the process goes to the next step S33.

If it is necessary to run the linker during debugging (step S19), decide whether to use the linker registered in the user environment registration field (step S20), and if you want to use the linker registered in the user environment registration field, select a specific option on the debugger. If you want to linker according to that specification (step S25), just hit the enter key and the debugger will run the linker according to that option to create the executable.

If a linker other than the linker registered in the user registration column is to be registered and used in the user environment registration column (step S21), the linker in the user environment registration column is changed to another linker surface and registered (step S24).

If you want to use the linker or finish using the debugger for other purposes (step S22), finish the execution of the debugger (step S37), otherwise run the linker on the user interface of the operating system or do anything else you need (step S25).

Otherwise, the user interface of the operating system may be executed in the debugger, and then the linker may be executed or other necessary operations may be performed on the user interface of the operating system (step S24).

If it is necessary to execute the user batch file registered in the user environment registration column during the debugging (step S26), it is determined whether to execute the user batch file registered in the user environment registration column, and if it is registered in the user environment registration column. When the user batch file is to be executed, the user batch file is executed when a specific selection item on the debugger is selected (step S30).

If you want to change the contents of the user batch file registered in the user registration column or execute another user batch file in the debugger (step S28), change the contents of the user batch file registered in the user registration column using the text editor. Or another user batch file is registered in the user environment registration column and then executed (step S31).

If you want to run a batch file that is different from the user batch file registered in the user environment registration column or if you want to finish executing the debugger for another purpose (step S29), terminate the use of the debugger and execute the required batch file on the operating system user interface. Or other necessary work (step S30).

If you want to run a user batch file that is different from the user batch file registered in the user environment registration column while using the debugger, or if you need to use the OS interface, perform the necessary operation after executing the OS interface (step S32). .

If you want to use debugger features other than text editors, compilers, linkers, or user batch files (step S33), you can use other debugger features (step S34). The use may be finished (step S36).

If you need to use other debugger features and need to use one or more of the following functions: text editor, compiler, linker, or user batch file, go to (Step S35), (Step S3) to (Step S32). You can repeat the process again. As described above, according to the present invention, since the debugger can directly call and use the function performing means associated with it, the key input operation can be greatly reduced compared to the case where the debugger is called and used in the conventional user interface, and the error according to the key input is relatively reduced. In addition, the operation time of the function performing means can be reduced, and the consistency of debugging can be improved.

Claims (1)

After executing the debugger (step S2), if there is an item to be changed in step S3 for determining whether to change the registered items in the user environment registration area, and if there is an item to be changed in step S3, the document editor name, compiler name, linker name, user batch Step S4 for changing the item of the processing file name, and if step S3 does not have a change item, it is determined whether or not the document editor needs to be executed during debugging (step S5), otherwise step S33 is executed; Step S6 for deciding whether or not to execute the document editor registered in step S6; if the document editor registered in the user environment registration area is to be used in step S6, proceed to the next step S9; otherwise, the document in the user environment registration area; Step S7 for deciding whether or not to use the editor after changing the editor name is selected. Step S9 for executing the document editor by selecting a specific item on the debugger for executing document spreading after registering the document editor name in the user environment registration area with another document editor name (Step S8). To determine whether to execute the text editor program or to finish the debugger execution for another purpose (step S11), and to terminate, to terminate the use of the debugger and to call the user interface of the operating system otherwise. Step S12 for executing a document editor or other operation on the user interface of the next operating system, and after executing steps S9 and S12, it is determined whether or not the compiler needs to be executed (step S10). Need to be executed by step S10 and step S10 In this case, it is determined whether or not to execute the compiler registered in the user environment registration column (step S13). If so, the process proceeds to the next step S18, and if the compiler is not executed by the step S13, the compiler registered in the user environment registration column. Change to another compiler, register and decide whether to execute (step S14), or if not, decide whether to end the use of the debugger to run the compiler or for other purposes (step S15), and to finish using the debugger If the step S15 does not end the use of the debugger, the user environment is invoked by calling the user interface of the operating system and then executing the compiler or other operations on the user interface of the operating system, and by executing the step S14. Register compiler different After changing to register with the compiler (Step S17), select the specific item on the debugger that allows the compiler to run and determine whether the linker needs to be executed during debugging after executing Step S18 and Steps S16 and S18. (Step S19) When there is no need to execute, the process proceeds to the next step S33. When it is necessary to execute, the process proceeds to step S20 for deciding whether or not to use the linker registered in the user environment registration column; To proceed, or to register and use a linker other than the linker registered in the user registration column in the user environment registration column (step S21), change the linker of the user environment registration to a different linker name to register and then use the linker, and step S21. Whether or not to end the use of the debugger to run the linker or for other purposes If it is determined (step S22), to end, the step proceeds to the next step S37 where the execution of the debugger is finished; if not to be completed by the step S22, the user interface of the operating system is called, and then the linker is executed on the operating system user interface, After executing step S23 and other steps S25 and S23, it is determined whether or not the user batch file registered in the user environment registration is executed during debugging (step S26). When it is necessary to execute the step proceeding to step S33 and the step S26, it is determined whether to execute the user batch file registered in the user environment registration column (step S27), and if so, the step proceeds to the next step S32; If not executed in step S27, the user's work registered in the user environment registration column Step S28 for deciding whether or not to use a user batch file different from the processing file in the user environment registration column, and the contents of the user batch file registered in the user environment registration column of the debugger by using a text editor if used in step S28. Step S32 to execute the user batch file by selecting a specific item on the debugger that causes the batch file to be registered in the user environment registration column during the debugger to be used after registering or changing to another batch file (Step S31). If it is not used in step S28, it is determined whether to execute the user batch file different from the user batch file registered in the user environment registration column or to end the debugger for another purpose (step S29), and to proceed to the next step S37 to finish. If it is not completed by the step S29, After calling the user interface of the system and executing the user batch file or performing other tasks on the user interface of the operating system, and executing the steps S32 and S30, a document editor, a compiler, a linker, If you want to use a debugger function other than a user batch file (step S33), you can use any of the document editor, compiler, and linker user batch files that use the debugger function. Determine whether it is necessary to execute it (step S35). If it is necessary to execute it, the steps from step S3 to step S32 are repeated again, and if it is not necessary, the steps (S36 and S37) of ending the use of the debugger are performed. Debugger control method of a program development apparatus comprising.