Machine independent debugger

Abstract

The present invention teaches a source-level debugger that defines symbol tables with a grammar. A grammar interface component is used by the compiler to automate portions of the debugger to construct and write the symbol table in a grammar thus simplifying the compiler. The grammar interface component is used by the debugger during execution of the target to read and decode the symbol table, thus simplifying the debugger. Using a grammar to specify the symbol table also documents the symbol table concisely and emphasizes that symbol tables are data structures, not file formats. Many of the pitfalls of working with low-level file formats can be avoided by focusing instead on grammar-based high-level data structures and automating the implementation details. Management of breakpoints is divided by splitting the nub into a client nub that is local to the target, a server nub that is local to the debugger. The management of breakpoints is localized to the client nub, thus saving communication time between the client nub and the server nub in support of breakpoint processing.

1 - 35  (cancelled)  
     
     
         36 . A computerized method for debugging a target program, the target program associated with a symbol table, comprising: 
 generating the symbol table described by a grammar; and    controlling execution of the target program in reference to the symbol table.    
     
     
         37 . The computerized method for debugging a target program as in  claim 36 , wherein the grammar comprises a machine-independent grammar.  
     
     
         38 . The computerized method for debugging a target program as in  claim 37 , wherein the machine-independent grammar further comprises the Abstract Syntax Description Language.  
     
     
         39 . The computerized method for debugging a target program as in  claim 36 , wherein the symbol table is stored separately from the target program.  
     
     
         40 . The computerized method for debugging a target program as in  claim 36 , wherein the controlling execution of the target program further comprises: 
 receiving a debugger command;    generating a command specified in a machine-independent grammar, the command in accordance with the debugger command;    sending the command; and    receiving a response encoded in a machine-independent grammar.    
     
     
         41 . The computerized method for debugging a target program as in  claim 36 , wherein the controlling further comprises reading symbol table information using a grammar interface component.  
     
     
         42 . A computerized method comprising: 
 generating computer-readable code for managing a symbol table represented in an abstract notation, the generating yielding generated code.    
     
     
         43 . The computerized method as in  claim 42 , wherein the abstract notation further comprises being specified by a grammar.  
     
     
         44 . The computerized method as in  claim 43 , wherein the grammar further comprises Abstract Syntax Description Language.  
     
     
         45 . The computerized method as in  claim 42 , wherein the symbol table further comprises an associated debugger.  
     
     
         46 . The computerized method as in  claim 45 , further comprising integrating the generated code into the debugger.  
     
     
         47 . The computerized method as in  claim 45 , further comprising integrating the generated code into a compiler.  
     
     
         48 . The computerized method as in  claim 42 , wherein the managing a symbol table further comprises: 
 constructing the symbol table;    reading from the symbol table; and    writing to the symbol table.    
     
     
         49 . A computerized method for debugging a target program, the target program associated with a symbol table, comprising: 
 defining the symbol table with a grammar; and    controlling execution of the target program in reference to the symbol table, wherein the controlling further comprises: 
 receiving a debugger command;  
 generating a command specified with a machine-independent grammar, the command in accordance with the debugger command;  
 sending the command; and  
 receiving a response encoded in a machine-independent grammar.  
   
     
     
         50 . A computerized method for creating debugging information, including a target program associated with a symbol table, the method comprising: 
 generating the target program;    generating the symbol table encoded in a machine-independent grammar;    storing the target program; and    storing the symbol table separate from the target program.    
     
     
         51 . A computer system for developing software, comprising: 
 a grammar-based tool for generating computer-readable code for managing a symbol table in a grammar notation, yielding generated code; and    a development tool operatively coupled to the generated code for interacting with a symbol table file.    
     
     
         52 . The computer system for developing software as in  claim 51 , wherein the development tool further comprises a computer program debugger.  
     
     
         53 . The computer system for developing software as in  claim 51 , wherein the development tool further comprises a computer program compiler.  
     
     
         54 . The computer system for developing software as in  claim 51 , wherein the symbol table is stored separately from the generated code.  
     
     
         55 . The computer system for developing software as in  claim 51 , wherein the grammar based tool further comprises asdlgen and the grammar further comprises the Abstract Syntax Description Language.  
     
     
         56 . A computer system for debugging a target executable program having a plurality of modules, the computer system comprising: 
 a server nub associated with a debugger, the server nub is configured to set stopping points common to the modules and to determine whether a stopping point corresponds to an extraneous breakpoint within a module, and in response to determining that the stopping point associated with the event notification corresponds to an extraneous breakpoint, the server nub is further configured to dismiss the encountered breakpoint; and    a client nub associated with the debugger, the client nub is configured to send an event notification to the server nub when the client nub encounters a stopping point, the event notification contains information about the stopping point.    
     
     
         57 . A computer-readable medium having computer-executable instructions to cause a computer to perform a method comprising controlling execution of a target program using a symbol table encoded in an abstract notation.  
     
     
         58 . A computer system for developing computer programs, comprising: 
 a software development tool; and    means for enabling interaction between the software development tool and a symbol table encoded in a grammar.    
     
     
         59 . The computer system for developing computer programs as in  claim 58 , wherein the interaction further comprises: 
 constructing the symbol table;    reading from the symbol table; and    writing to the symbol table.    
     
     
         60 . The computer system for developing computer programs as in  claim 58 , wherein the software development tool further comprises a computer program compiler.  
     
     
         61 . The computer system for developing computer programs as in  claim 58 , wherein the software development tool further comprises a computer program debugger.  
     
     
         62 . A computer-readable medium having stored thereon a symbol table data structure comprising data encoded in an abstract notation.  
     
     
         63 . The computer-readable medium as in  claim 62 , wherein the abstract notation further comprises a grammar.