Patent US5956479A successfully refreshed from Google Patents.
US5956479A
Expired / Lapsed
US
⏱️ 0.0 years remaining
Demand based generation of symbolic information
Assignee: Apple Inc
•
Filing: 1995-11-13
•
Granted: 1999-09-21
•
Expires: 2015-11-13
Abstract
Abstract A human oriented object programming system (HOOPS) and its debugger provide an interactive and dynamic modeling system to assist in the incremental generation of symbolic information of computer programs which facilitates the development of complex computer programs such as operating systems and large applications with graphic user interfaces (GUIs). A program is modeled as a collection of units called components. A component represents a single compilable language element such as a class or a function. One major functionality built on HOOPS is the debugger, using symbolic properties. The database stores the components and properties. The debugger, using a GUI, displays to the user the execution state of the program. To display the execution state in terms of the programmer's source code, the debugger demands retrieval and/or generation of the symbolic properties of the program. The compiler, which is responsible for calculating the dependencies associated with a component, uses those dependencies to generate the information stored in symbolic properties. The debugger matches versions of source and object code and retrieves source code configuration as needed. Symbolic properties that are stored in the database can be removed to reduce database and disk memory usage; they can be later reconstructed using the same method of demand-based generation of symbolic information.
Inventors
- 👤 Peter J. McInerney
- 👤 Lawrence L. You
- 👤 Michael D. Wimble
Bibliographic Details
Application Number
—
Jurisdiction
US
Data Source
google_patents
Last Synchronized
2026-10-29 22:07
CPC Classifications
G; G06; G06F; G06F11/00; G06F11/36; G06F11/3698
Claims Analysis
Total Claims: 27
Claim 1
Independent Claim
171 words
In a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, and a debugger for monitoring execution of the program during debugging to detect a program execution halt, a method for dynamically generating symbolic debugging information, comprising the steps of: (a) when program execution halts during debugging, using the program counter value to locate a component in the database; (b) checking the attribute of the located component to determine whether symbolic debugging information relating the object code to the source code is valid; (c) generating the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) associating valid symbolic debugging information with the located component; and (e) using the debugger to continuing debugging the program.
Claim 2
Dependent Claim
171 words
In a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, and a debugger for monitoring execution of the program during debugging to detect a program execution halt, a method for dynamically generating symbolic debugging information, comprising the steps of: (a) when program execution halts during debugging, using the program counter value to locate a component in the database; (b) checking the attribute of the located component to determine whether symbolic debugging information relating the object code to the source code is valid; (c) generating the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) associating valid symbolic debugging information with the located component; and (e) using the debugger to continuing debugging the program.
Claim 3
Dependent Claim
33 words
The method of claim 1, wherein step (a) comprises the steps of: (a1) using the program counter value to address a cache memory; and (a2) obtaining a component name from the cache memory.
Claim 4
Dependent Claim
55 words
The method of claim 2, wherein step (a) comprises the steps of: (a3) converting the program counter value into a component name when the cache memory does not contain a component name at a location addressed by the program counter value; and (a4) storing the component name determined in step (a3) in the cache memory.
Claim 5
Dependent Claim
55 words
The method of claim 1, wherein step (c) comprises the step of: (c1) using the compiler to create, as part of the symbolic debugging information, at least one map which indicates a relation between the component object code and the component source code; and (c2) associating the at least one map with the located component.
Claim 6
Dependent Claim
62 words
The method of claim 1, wherein each computer program is constructed as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces and wherein step (c) comprises the step of: (c3) recompiling source code for the located component and all components which depend on the located component.
Claim 7
Dependent Claim
27 words
The method of claim 1, wherein step (c) comprises the step of: (c4) updating symbolic debugging information which was originally created by compiling all of the components.
Claim 8
Dependent Claim
50 words
The method of claim 1, further comprising the step of: (f) executing a browser program with the symbolic debugging information generated in step (c) to present source code from a located component on the display when program execution halts during debugging in response to an exception generated by the program.
Claim 9
Dependent Claim
28 words
The method of claim 7, wherein step (f) comprises the step of: (f1) applying a program thread which generated the exception as an input to the browser program.
Claim 10
Dependent Claim
187 words
Apparatus for dynamically generating symbolic debugging information for use in a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, and a debugger for monitoring execution of the program to detect a program execution halt during debugging, the apparatus comprising: (a) means responsive to a program execution halt during debugging, for using the program counter value to locate a component in the database; (b) means responsive to the attribute of the located component for determining whether symbolic debugging information relating the object code to the source code is valid; (c) means for controlling a compiler to generate the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) means for associating valid symbolic debugging information with the located component; and (e) means for controlling the debugger to continuing debugging the program.
Claim 11
Dependent Claim
187 words
Apparatus for dynamically generating symbolic debugging information for use in a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, and a debugger for monitoring execution of the program to detect a program execution halt during debugging, the apparatus comprising: (a) means responsive to a program execution halt during debugging, for using the program counter value to locate a component in the database; (b) means responsive to the attribute of the located component for determining whether symbolic debugging information relating the object code to the source code is valid; (c) means for controlling a compiler to generate the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) means for associating valid symbolic debugging information with the located component; and (e) means for controlling the debugger to continuing debugging the program.
Claim 12
Dependent Claim
51 words
The apparatus of claim 9, wherein the means for using the program counter value to locate the component comprises a cache memory for storing at least one component name and means for using the program counter value to address the cache memory to obtain a component name from the cache memory.
Claim 13
Dependent Claim
60 words
The apparatus of claim 10, wherein the means for using the program counter value to locate the component comprises means for converting the program counter value into a component name when the cache memory does not contain a component name at a location addressed by the program counter value and means for storing the component name in the cache memory.
Claim 14
Dependent Claim
56 words
The apparatus of claim 9, wherein the compiler controlling means comprises means for using the compiler to create, as part of the symbolic debugging information, at least one map which indicates a relation between the component object code and the component source code and means for associating the at least one map with the located component.
Claim 15
Dependent Claim
66 words
The apparatus of claim 9, wherein each computer program is constructed as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces and wherein the compiler controlling means comprises means for controlling the compiler to recompile source code for the located component and all components which depend on the located component.
Claim 16
Dependent Claim
29 words
The apparatus of claim 9, wherein the compiler controlling means comprises means for updating symbolic debugging information which was originally created by compiling and linking all of the components.
Claim 17
Dependent Claim
42 words
The apparatus of claim 9, further comprising means for executing a browser program with the symbolic debugging information to present source code from a located component on the display when program execution halts in response to an exception generated by the program.
Claim 18
Dependent Claim
27 words
The apparatus of claim 15, wherein the executing means comprises means for applying a program thread which generated the exception as an input to the browser program.
Claim 19
Dependent Claim
208 words
A computer program product for use in a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, a compiler, and a debugger for monitoring execution of the program to detect a program execution halt during debugging, a computer program product for dynamically generating symbolic debugging information comprising a computer usable medium having computer readable program code thereon, including: (a) program code for using the program counter value to locate a component in the database when program execution halts during debugging; (b) program code for checking the attribute of the located component to determine whether symbolic debugging information relating the object code to the source code is valid; (c) program code for controlling the compiler to generate the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) program code for associating valid symbolic debugging information with the located component; and (e) program code for controlling the debugger to continuing debugging the program.
Claim 20
Dependent Claim
208 words
A computer program product for use in a computer system having a memory, a display, a program counter with a value, a program consisting of a set of named components stored in a database in the memory, each component including an attribute indicating whether the component data is valid, source code for implementing the component, and object code for executing the component, a compiler, and a debugger for monitoring execution of the program to detect a program execution halt during debugging, a computer program product for dynamically generating symbolic debugging information comprising a computer usable medium having computer readable program code thereon, including: (a) program code for using the program counter value to locate a component in the database when program execution halts during debugging; (b) program code for checking the attribute of the located component to determine whether symbolic debugging information relating the object code to the source code is valid; (c) program code for controlling the compiler to generate the symbolic debugging information by recompiling the source code of the located component when the symbolic debugging information is not valid; (d) program code for associating valid symbolic debugging information with the located component; and (e) program code for controlling the debugger to continuing debugging the program.
Claim 21
Dependent Claim
45 words
The computer program product of claim 17, wherein the program code for locating a component in the database comprises program code for using the program counter value to address a cache memory and program code for obtaining a program component name from the cache memory.
Claim 22
Dependent Claim
68 words
The computer program product of claim 18, wherein the program code for locating a component in the database comprises program code for converting the program counter value into a component name when the cache memory does not contain a component name at a location addressed by the program counter value and program code for storing the component name converted from the program counter value in the cache memory.
Claim 23
Dependent Claim
63 words
The computer program product of claim 17, wherein the program code for controlling the compiler comprises program code for using the compiler to create, as part of the symbolic debugging information, at least one map which indicates a relation between the component object code and the component source code and program code for associating the at least one map with the located component.
Claim 24
Dependent Claim
71 words
The computer program product of claim 17, wherein each computer program is constructed as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces and wherein program code for controlling the compiler comprises program code for controlling the compiler to recompile source code for the located component and all components which depend on the located component.
Claim 25
Dependent Claim
32 words
The computer program product of claim 17, wherein program code for controlling the compiler comprises program code for updating symbolic debugging information which was originally created by compiling all of the components.
Claim 26
Dependent Claim
48 words
The computer program product of claim 17, further comprising program code executing a browser program with the symbolic debugging information generated by the compiler to present source code from a located component on the display when program execution halts in response to an exception generated by the program.
Claim 27
Dependent Claim
36 words
The computer program product method of claim 23, wherein the program code for executing the browser program comprises program code for applying a program thread which generated the exception as an input to the browser program.
References Cited (Backward Citations)
US5412799A
Cited
US5361351A
Cited
US5560009A
Cited
US5454086A
Cited
US5513317A
Cited
US5408665A
Cited
US5533192A
Cited
USPTO Annuity & Maintenance Windows
| Annuity Stage | Window Opens | Payment Deadline | Surcharge Period Until | Estimated Fee | Status |
|---|---|---|---|---|---|
| 3.5 Years (Year 4) | 2002-09-20 | 2003-03-22 | 2003-09-21 | $2000.00 | Window Closed / Lapsed |
| 7.5 Years (Year 8) | 2006-09-20 | 2007-03-22 | 2007-09-21 | $3760.00 | Window Closed / Lapsed |
| 11.5 Years (Year 12) | 2010-09-20 | 2011-03-22 | 2011-09-21 | $7700.00 | Window Closed / Lapsed |