Method and system for program editing

• US 20050034109A1
• Filed: 07/21/2004
• Published: 02/10/2005
• Est. Priority Date: 06/04/2001
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Magruder, Michael M., Hamilton, Jennifer A., Miller, James S., Zhang, Li, Crawford, Brian R., Hallam, Peter A., Morrison, Vance P., Dussud, Patrick H., Hamby, John L., Rivard, John J., Trowbridge, Sean E., Steiner, Steven J., Spencer, Sam, Hogg, James H., Heydarian, Habib, Carmichael, Ian H., Chenier, Mario, Evans, William G., Sullivan, Lawrence B., Zander, Jason L., Rosen, Douglas
• Granted Patent: US 7,516,441 B2
• Time in Patent Office: Days
• US Class Current: 717/140
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 8/34 Graphical or visual programming
• CPC Class Codes: G06F 8/48 Incremental compilation software reuse G06F8/36
• CPC Class Codes: G06F 9/455 Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure

Abstract

A system and method of providing edit and continue support in a software program debugging environment. “Edit and continue” support allows a user (e.g., programmer and/or developer) to update the code and/or data structure(s) of an executing program while it is running. After the user has finished editing their code and resumes execution, an integrated development environment (IDE) propagates the edit(s) into a common language runtime (CLR) environment before continuing. Therefore, from the CLR environment'"'"'s perspective, an edit is a block of intermediate language code (IL) and/or metadata that is inserted into a running process. The IDE can facilitate: determining “legality” of an edit; building the edit; sending the edit to the CLR environment; and/or, facilitating the CLR environment switch execution to the edited code.

Claims

1. A common language runtime environment comprising:

an assembly comprising an intermediate language component and metadata associated with a source code component;

an edit and continue component that, in response to notification of a change of a function associated with the assembly, provides current position information, and, receives information associated with a new position information, the edit and continue component facilitating execution of the assembly based upon the new position information.

2. The environment of claim 1, further comprising an intermediate language compiler that generates native code based on the assembly.

3. The environment of claim 1, further comprising a runtime code manager that facilitates loading and operating of the assembly by a processor.

4. An integrated development environment comprising:

a source code component comprising high-level source code of a computer software program;

a user interface that facilitates debugging of the software program;

an application program interface that facilitates communication between the user and a common language runtime environment running native code associated with the software program, the integrated development environment facilitating editing of the high-level source code, determining legality of an edit, building the edit, if it is determined to be legal, sending information associated with the edited software program to the common language runtime environment, and, facilitating execution of the edited software program in the common language runtime environment.

5. The environment of claim 4, the high-level source code being based, at least in part, upon at least one of Visual Basic, C++, C#, Java Script, APL, COBOL, Pascal, Eiffel, Haskell, ML, Oberon, Perl, Python, Scheme, Smalltalk and Objective Caml.

6. The environment of claim 4, further comprising a source compiler that compiles the source code component to generate an intermediate language component.

7. The environment of claim 4, a legal edit comprising at least one of adding a non-virtual private method to a class, adding a private field to a class, and adding a private property to a class.

8. The environment of claim 4, wherein editing of an inactive parameterized function is not legal.

9. The environment of claim 4, wherein editing of an active function is not legal if it increases the exception-handler nesting to more than a threshold amount, or increases the nesting level of a function that already has more than a second threshold amount of levels.

10. The environment of claim 4, wherein editing of an active function is not legal if it adds a filter, finally, fault, and/or or catch block that contains the instruction pointer.

11. The environment of claim 4, wherein editing of an active function is not legal if the function employs localloc.

12. The environment of claim 4, wherein editing of an active non-leaf function is not legal if the edit adds or removes a try block that contains an instruction pointer.

13. The environment of claim 4, wherein editing of an active non-leaf function is not legal if it adds, removes or changes the contents of an exception handler whose try block contains an instruction pointer.

14. The environment of claim 4, wherein the information sent to the common language runtime environment associated with the edited software program includes a block of metadata and/or a block of intermediate language code.

15. The environment of claim 4, wherein the integrated development environment provides an intermediate language offset into an edited function and remaps a stepper or a break point.

16. A method facilitating programming editing comprising:

receiving a break point event;

requesting edit and continue state information;

receiving an edit to a function of a source code component;

determining whether the edit is legal; and

,

if the edit is legal;

committing the change;

receiving a remap break point event;

providing a modified instruction pointer based on the edited function; and

,

performing a remap operation.

17. The method of claim 16, further comprising:

executing a first portion of native code;

suspending execution of the native code at a breakpoint; and

,

sending the break point event.

18. The method of claim 16, further comprising:

updating metadata based on the edit; and

,

updating an intermediate language component based on the edit.

19. The method of claim 16, further comprising:

continuing execution of the unedited native code until a remap break point is reached; and

,

providing current position information.

20. A computer readable medium having stored thereon computer executable instructions for carrying out the method of claim 16.

21. A method facilitating lifetime of a dependent object comprising:

providing a handle pair listing a parent object and a dependent object;

promoting the dependent object, if the parent object is promoted;

clearing the handle if the parent is not promoted; and

,

destroying the handle when the parent object is destroyed.