Active debugging environment for debugging mixed-language scripting code

• US 6,353,923 B1
• Filed: 01/30/1998
• Issued: 03/05/2002
• Est. Priority Date: 03/12/1997
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Bogle, Phillip Lee, McKelvie, Samuel James, Katzenberger, Gary S., Welland, Robert Victor
• Primary Examiner(s): Chaki, Kakali
• Application Number:
  US09/016,760
• Time in Patent Office: 1,495 Days
• Field of Search: 395/704, 395/705, 717/4, 717/5, 717/6, 717/1, 717/2, 714/34, 714/38, 703/23, 703/26, 703/27
• US Class Current: 717/128
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 9/45512 Command shells
• CPC Class Codes: G06F 9/541 via adapters, e.g. between incompatible applications

Abstract

An active debugging environment for debugging a virtual application that contains program language code from multiple compiled and/or interpreted programming languages. The active debugging environment is language neutral and host neutral, where the host is a standard content centric script host with language engines for each of the multiple compiled and/or interpreted programming languages represented in the virtual application. The active debugging environment user interface can be of any debug tool interface design. The language neutral and host neutral active debugging environment is facilitated by a process debug manager that catalogs and manages application specific components, and a machine debug manager that catalogs and manages the various applications that comprise a virtual application being run by the script host. The process debug manager and the machine debug manager act as an interface between the language engine specific programming language details and the debug user interface.

Claims

1. A method of operating an active debugging environment to debug a virtual application, said method comprising:

populating a script host with a script for a virtual application that assimilates plural script fragments for automating one or more objects of an object model provided through the script host, the plural script fragments including a first script fragment from a first language and a second script fragment from a second language;

dynamically activating said active debugging environment; and

running said script by said script host under control of said active debugging environment in a manner comprising;

defining at least one event monitoring case by way of a debug user interface;

for each of said at least one event monitoring case, coordinating implementation in a language-dependent manner as appropriate for a script fragment in said script;

identifying an occurrence of each of said at least one event monitoring case; and

activating a predefined response to said occurrence.

2. A method according to claim 1 wherein said populating includes:

dynamically establishing a language engine for each language represented in said virtual application.

3. A method according to claim 1 including:

supporting any one of a plurality of integrated development environment user interfaces to said active debugging environment in a language neutral and host independent manner.

4. A method according to claim 3 including:

transmitting any portion of said script to said supported integrated development environment user interface to facilitate source code and virtual application context viewing by said debug user; and

receiving data from said integrated development environment user interface indicative of user-input commands to control operation of said active debugging environment.

5. A method according to claim 1 wherein said activating a predefined response includes:

generating a view of said script to a debug user that is relevant to said event; and

dynamically altering said script by script edit facilities in an integrated development environment user interface.

6. A method according to claim 5 further including:

running said script on said script host with edited changes absent any run-time interruptions to said active debugging environment.

7. In a computer system, a method of operating an active debugging environment to debug as a virtual application plural scriptlets that automate the objects of an object model, the method comprising:

receiving plural scriptlets for automating one or more objects of an object model exposed through an Internet browser, the plural scriptlets including a first scriptlet written in a first scripting language and a second scriptlet written in a second scripting language;

defining an active debugging environment that is scripting language-neutral;

based upon the plural scriptlets and context information for the plural scriptlets, generating a virtual application;

based upon at least one scripting language-neutral script debugging case for the virtual application, directing scripting language-dependent execution of the plural scriptlets during automation of the one or more objects of the object model.

8. In a computer system in which code fragments automate objects provided through a host, an active environment that allows debugging the code fragments as a single debuggable entity, the active environment comprising:

an entity register that manages interaction between a debug user interface and one or more debuggable entities, each debuggable entity assimilating one or more code fragments, each code fragment written in one of plural languages, the debug user interface for accepting one or more debugging cases;

an entity-specific debug manager that coordinates language-dependent implementation of debugging cases for a particular debuggable entity during automation of objects provided through the host according to the one or more code fragments of the particular debuggable entity.

9. The active environment of claim 8 wherein the entity-specific debug manager communicates a first debugging case to a first language engine that implements the first debugging case according to a first language, and wherein the entity-specific debug manager communicates a second debugging case to a second language engine that implements the second debugging case according to a second language.

10. The active environment of claim 9 wherein the entity-specific debug manager coordinates breakpoints and stepping between the first and second language engines.

11. The active environment of claim 9 wherein the entity-specific debug manager merges stack frames for the first and second language engines.

12. The active environment of claim 8 wherein the particular debuggable entity is a default debuggable entity that assimilates one or more code fragments in a first language.

13. In a computer system in which aggregated script fragments automate scriptable objects provided through a host, the aggregated script fragments including one or more script fragments each written in one of plural scripting languages, a debugging user interface that facilitates debugging the aggregated script fragments, the debugging user interface comprising:

view producing means for presenting to a user a script view;

event setting means for defining one or more control points in the aggregated script fragments; and

event communicating means for conveying the one or more control points to a debugging environment through which each of the one or more control points is implemented in a language-dependent manner suitable for the script fragment affected by the control point.

14. The debugging user interface of claim 13 further comprising:

editing means for dynamic script fragment modification during debugging.

15. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, wherein the active debugging environment coordinates implementation of a second debug event according to the second language, and wherein the intervening in automation comprises;

communicating the first debug event to a first language engine that implements debug events in a first language-dependent manner; and

communicating the second debug event to a second language engine that implements debug events in a second language-dependent manner.

16. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language, wherein the providing comprises;

providing an entity register for managing interaction between a debug user interface and one or more debuggable entities, the debug user interface for accepting and consistently defining debug event input for a particular one of the one or more debuggable entities; and

providing an entity-specific debug manager for coordinating language-dependent debug event implementation;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, and wherein the active debugging environment coordinates implementation of a second debug event according to the second language.

17. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language, wherein the languages are scripting languages;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, and wherein the active debugging environment coordinates implementation of a second debug event according to the second language.

18. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, wherein the active debugging environment coordinates implementation of a second debug event according to the second language, and wherein the intervening in automation comprises imposing the plural debug events on the debuggable entity after automation begins.

19. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, wherein the active debugging environment coordinates implementation of a second debug event according to the second language, and wherein the intervening in automation comprises;

imposing the plural debug events on the debuggable entity before automation begins; and

imposing one or more additional debug events on the debuggable entity after automation begins.

20. A computer-readable medium storing instructions for performing a method of facilitating the debugging of aggregate code that automates one or more scriptable objects provided through a host, the method comprising:

providing an active debugging environment for interacting with a host that provides one or more scriptable objects capable of automation by an aggregate code that includes a first code fragment written in a first language and a second code fragment written in a second language;

recognizing a debuggable entity created from the aggregate code and context information;

based upon plural debug events for the debuggable entity, intervening in automation, wherein the active debugging environment coordinates implementation of a first debug event according to the first language, and wherein the active debugging environment coordinates implementation of a second debug event according to the second language; and

wherein one or more additional code fragments join the aggregate code during automation.