Method and system for providing a visual debugger for an interpreted statistical language
Methods and systems for visual debugging of an interpreted language in, for example, an Interactive Development Environment are provide. Example embodiments provide an S-PLUS Visual Debugging System (“SPVDS”), which includes an S-PLUS Workbench Debugger (“SPWD”) that provides “step-based” visual debugging, enabling programmers to step through execution of expressions by setting and otherwise managing breakpoints, examining variables and expressions, and controlling execution such as by step, step-in, step-out, step-over, continue, stop commands. In addition, the SPWD provides a profiler which tracks the number and duration of calls to functions and the amount of memory allocated to variables. This abstract is provided to comply with rules requiring an abstract, and it is submitted with the intention that it will not be used to interpret or limit the scope or meaning of the claims.
1. A method in a computing system for debugging interpreted code in a visual debugger using breakpoints to facilitate step-based evaluation of expressions, comprising:
presenting a visual user interface for receiving debugging commands;
in response to a received debug command to set or change an indicated breakpoint in a segment of code that is expressed in an interpreted programming language and that defines one or more expressions,
determining the nearest enclosing expression to the indicated breakpoint, including when the nearest enclosing expression begins on a line of source code associated with the code segment that is different from a line of the associated source code that contains the indicated breakpoint; and
generating a breakpoint address that indicates a location in the segment of code that corresponds to the beginning of the determined enclosing expression when the code segment is evaluated by:
generating a logical breakpoint address that indicates the beginning of the determined enclosing expression; and
mapping the generated logical breakpoint address to a memory address that corresponds to an element in a parse tree generated for evaluating the determined enclosing expression, the element corresponding to the beginning of the determined enclosing expression; and
causing the code segment to be evaluated using an interpreter for the interpreted programming language, such that evaluation automatically stops when the location in the code segment that corresponds to the breakpoint address is encountered; and
causing one or more source code statements that correspond to and indicate the location in the code segment where the evaluation stopped to be displayed in the visual interface; and
receiving one or more additional debug commands to further control the evaluation of the code segment or to examine aspects of the code segment under evaluation.
2. The method of claim 1 wherein the received debug command to set or change the indicated breakpoint is indicated by selection of a portion of a line in source code associated with the code segment and wherein the determining the nearest enclosing expression to the indicated breakpoint determines an expression that begins on a line that is different from the line associated with the selected portion.
3. The method of claim 2 , further comprising receiving a second debug command that sets a second indicated breakpoint on the same line in the source code associated with the code segment, such that a plurality of breakpoints are concurrently active for the code segment.
4. The method of claim 1 , the code segment associated with a current file that contains the expressions that define the code segment, wherein the nearest enclosing expression to the indicated breakpoint refers to a function that is defined outside of the current file.
5. The method of claim 1 wherein the visual user interface is an Interactive Development Environment (“IDE”) having a predefined set of interfaces for developing and testing program code.
6. The method of claim 5 wherein the IDE uses Eclipse code, and the visual user interface is implemented as a debug perspective plug-in.
7. The method of claim 5 wherein no launch configuration information is required to be forwarded to the IDE prior to debugging the code.
8. The method of claim 1 wherein the interpreted programming language is S-PLUS.
9. The method of claim 1 wherein the interpreted programming language is a language used to generate statistical programs.
10. The method of claim 1 wherein the one or more additional debug commands include one or more of commands for stepping execution, marking or unmarking breakpoints, or continuing execution.
11. The method of claim 1 wherein the one or more additional debug commands include one or more of commands for examining an associated value of an object, an expression, or a variable.
12. The method of claim 1 wherein the breakpoint address is generated without using pre-computed symbolic information associated with the code segment.
13. A non-transitory computer-readable medium whose contents enable a computing system to provide for debugging of interpreted code in a visual debugger using breakpoints that facilitate step-based evaluation of expressions, by performing a method comprising:
presenting a user interface for receiving debugging commands;
in response to a received debug command to set or change an indicated breakpoint in a segment of code that is expressed in an interpreted programming language and that defines one or more expressions,
determining the nearest enclosing expression to the indicated breakpoint, including when the nearest enclosing expression begins on a line of source code associated with the code segment that is different from a line of the associated source code that contains the indicated breakpoint; and
generating a breakpoint address that indicates a location in the segment of code that corresponds to the beginning of the determined enclosing expression when the code segment is evaluated by:
generating a logical breakpoint address that indicates the beginning of the determined enclosing expression; and
mapping the generated logical breakpoint address to a memory address that corresponds to an element in a parse tree generated for evaluating the determined enclosing expression, the element corresponding to the beginning of the determined enclosing expression; and
causing the code segment to be evaluated using an interpreter for the interpreted programming language, such that evaluation automatically stops when the location in the code segment that corresponds to the breakpoint address is encountered; and
causing one or more source code statements that correspond to and indicate the location in the code segment where the evaluation stopped to be displayed in the visual interface.
14. The computer-readable medium of claim 13 , the method further comprising:
receiving one or more additional debug commands to further control the evaluation of the code segment or to examine values of variables or expressions contained in the code segment.
15. The computer-readable medium of claim 13 wherein the visual interface is an Interactive Development Environment (“IDE”).
16. The computer-readable medium of claim 13 wherein the computer-readable medium is a memory in a computing device.
17. The computer-readable medium of claim 13 wherein the contents are instructions that, when executed, cause the computing system to perform the method.
18. The computer-readable medium of claim 13 wherein the instructions that perform the causing of the code segment to be evaluated using the interpreter for the interpreted programming language, such that evaluation automatically stops when the location in the code segment that corresponds to the breakpoint address is encountered are implemented as hooks in an existing interpreter.
19. A computing system for debugging code programmed in an interpreted language defining a plurality of expressions, comprising:
a memory;
a computer processor;
a parser stored in the memory and configured, when executed by the computer processor, to create a parse tree for an indicated function;
a debug command module stored in the memory and configured, when executed by the computer processor, to receive debugging commands from a user via a visual user interface and, when a command is received to set or change a breakpoint in the indicated function, generating a logical breakpoint address that indicates an expression contained within the function;
a debug handler stored in the memory and configured, when executed by the computer processor, to receive the generated logical breakpoint address, resolve the logical breakpoint address into a memory address that corresponds to a location in the parse tree created for the function, record information to associate the breakpoint with the function; and
an evaluation module for the interpreted language, stored in the memory, and configured, when executed by the computer processor, to receive an expression in the interpreted language that contains a call to the function, and traverse a parse tree corresponding to the received expression to generate output defined by evaluating the expression such that, when the location that corresponds to the breakpoint associated with the function is encountered in the parse tree created for the function, the evaluation module pauses to receive debug commands to further control evaluation of the expression or to examine values of objects associated with the expression.
20. The computing system of claim 19 wherein the interpreted language is S-PLUS.
21. The computing system of claim 19 wherein the parser is a preexisting parser unmodified to support debugging operations.
22. The computing system of claim 19 wherein the evaluation module is modified to examine each node in a parse tree when the node is traversed to determine whether a breakpoint has been set.
23. The computing system of claim 19 wherein the debug command module and debug handler are executed in separate processes.
24. The computing system of claim 19 wherein the debug command module and debug handler are hosted on separate machines.
25. The computing system of claim 19 wherein the debug commands to further control evaluation of the expression include one or more of commands for stepping execution, marking or unmarking breakpoints, or continuing execution.
26. The computing system of claim 19 wherein the debug commands to examine values of objects associated with the expression include one or more of commands for examining an associated value of an object, an expression, or a variable.
27. A method in a computing system for debugging code for an interpreted language, comprising:
presenting a user interface for receiving debugging commands;
in response to a received debug command from the user interface to set or change a breakpoint in an indicated function, generating a logical breakpoint address that logically indicates the beginning of a determined enclosing expression within the indicated function;
mapping the logical breakpoint address into a memory address that corresponds to a location in a parse tree produced by a parser that is unmodified to handle debugging, the location corresponding to the beginning of evaluation of the determined enclosing expression; and
under control of a debug handler of a language interpreter, evaluating the indicated function according to the produced parse tree; and halting evaluation when the location in the parse tree that corresponds to the breakpoint is encountered, such that debug commands can be processed to further control evaluation of the expression or to examine values of objects associated with the expression.
28. The method of claim 27 wherein the interpreted language is a language used to generate statistical programs.
29. The method of claim 27 wherein the interpreted language is S-PLUS.
30. The method of claim 27 wherein the interface is part of an Interactive Development Environment (“IDE”).
31. The method of claim 30 wherein the IDE is Eclipse.
32. The method of claim 27 wherein the interface is a command line debugger.
33. The method of claim 27 , further comprising using a secondary parser to generate the logical breakpoint address.
34. The method of claim 33 wherein the secondary parser is a Java-based parser.
35. The method of claim 33 wherein the parser is a C-based parser.
36. The method of claim 27 , further comprising executing additional debug commands when a breakpoint is encountered while evaluating the code.
37. The method of claim 36 wherein the additional debug commands are executed using a hook in an evaluation function of the language interpreter.
38. A non-transitory computer-readable medium whose contents enable a computing system to perform debugging of code written in an interpreted language, by performing a method comprising:
presenting a user interface for receiving debugging commands;
in response to a received debug command from the user interface to set or change a breakpoint in the an indicated function, generating a logical breakpoint address that logically indicates the beginning of a determined enclosing expression;
mapping the logical breakpoint address into a memory address that corresponds to a location in a parse tree produced by a parser that is unmodified to handle debugging, the location corresponding to the beginning of evaluation of the determined enclosing expression; and
under control of an evaluation module of a debug handler for interpreting the language, evaluating the indicated function according to the produced parse tree; and halting execution when the location in the parse tree that corresponds to the breakpoint is encountered, such that debug commands can be processed to further control evaluation of the expression or to examine values of objects associated with the expression.
39. The computer-readable medium of claim 38 wherein the computer-readable medium is a memory in a computing device.
40. The computer-readable medium of claim 38 wherein the contents are instructions that, when executed, cause the computing system to perform the method.