Method and apparatus of incrementally linking components of a modeled computer program

• US 5,519,866 A
• Filed: 06/28/1993
• Issued: 05/21/1996
• Est. Priority Date: 06/28/1993
• Status: Expired due to Term

• Current Assignee: Apple Inc.
• Original Assignee: Taligent, Inc. (HP Inc.)
• Inventors: Lawrence, Roger P., Dance, John R.
• Primary Examiner(s): Kriess, Kevin A.
• Assistant Examiner(s): CHAVIS, JOHN Q
• Application Number:
  US08/085,490
• Time in Patent Office: 1,058 Days
• Field of Search: 395/700, 395/650
• US Class Current: 717/162
• CPC Class Codes: G06F 8/48 Incremental compilation software reuse G06F8/36
• CPC Class Codes: G06F 8/54 Link editing before load time
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management

Abstract

A human oriented object programming system provides an interactive and dynamic process for the incremental building of computer programs which facilitates the development of complex computer programs such as operating systems and large applications with graphic user interfaces (GUIs). The 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. The major functionalities are the database, the compiler, build and link mechanism. The database stores the components and properties. The compiler, along with compiling the source code of a property, and generating object code is responsible for calculating the dependencies associated with a component. The build mechanism uses properties of components along with the compiler generated dependencies to correctly and efficiently sequence the compilation of components during a build process. The link mechanism links all object code as the component stores it in the component database. Only updated components require linking operations.

Claims

1. A method for use on a computer system with a memory for incrementally linking a user-modified part of a computer program with previously compiled and linked parts of the computer program, the computer program being comprised of source code stored in the memory and the method comprising the steps of:

(a) receiving into the memory a user-created model of the computer program, the model comprising an ordered collection of components, each of the collection of components having a source code property referencing a portion of the source code in the memory, an object code property specifying a portion of the memory and client information identifying others of the collection of components which must be changed when the each component is changed;

(b) compiling and linking the source code portions in each of the collection of components to store executable object code in the memory portions specified by the object code properties of each of the collection of components;

(c) modifying a first portion of the source code in response to a user request and identifying one of the collection of components having a source code property which references the first source code portion;

(d) accessing the client information of the one component to identify others of the collection of components which must be changed and;

(e) concurrently compiling and linking the one component and all of the other components that must be changed to store new executable object code in the memory portions specified by the object code properties of the one component and the other components identified in step (d).

2. The method of claim 1, wherein the first source code portion comprises an interface portion for communicating with others of the collection of components and an implementation portion comprising a remainder of the first source code portion which does not communicate with others of the collection of components and wherein the one component includes an interface attribute, describing the interface portion, and an implementation attribute, describing the implementation portion, and wherein step (c) includes the step of

(c.1) updating the implementation attribute when the implementation portion is modified in accordance with the user request and updating the interface attribute when the interface portion is modified in accordance with the user request;

and wherein step (e) includes the steps of;

(e.1) examining the implementation attribute and the interface attribute to determine whether only the implementation portion was modified in step (c) and,

(e.1.1) if so, concurrently compiling and incrementally linking only the one component, and

(e.1.2) if not, concurrently compiling and incrementally linking the one component and all of the other components that must be changed.

3. The method of claim 2 wherein the first source code portion comprises inline source code and the one component further includes an inline attribute, and wherein step (c) includes the step of:

(c.1) updating the inline attribute when the inline source code is modified in accordance with the user modification request, and wherein step (e) includes the step of;

(e.2) examining the inline attribute to determine whether the inline source code was modified and,

(e.2.1) if so, concurrently compiling and incrementally linking the one component and all of the other components that must be changed.

4. The method of claim 1, wherein the method further comprises the steps of:

(f) relocating the new executable object code of the one component from an old memory portion specified by the object code property of the one component to a new memory portion when the new executable object code does not fit into the old memory portion; and

(g) updating the object code property of the component which has its new executable object code relocated in step (f) to specify the new memory portion.

5. The method of claim 4, wherein the new executable object code has a name and the one component includes a declaration attribute relating the new executable object code name to the memory portion holding the new executable object code and wherein the method further comprises the step of:

(h) updating the declaration attribute of the one component which has its new executable object code relocated in step (f) to specify the new memory portion.

6. The method of claim 5 wherein the computer system includes a symbol table stored in the memory, the symbol table relating the memory portion holding the new executable object code of the one component with the new executable object code name and wherein the method further comprises the steps of:

(i) updating the symbol table to specify the new memory portion of the new executable object code;

(j) informing the others of the collection of components which must be changed that the declaration attribute of the one component has been updated, and

(k) concurrently compiling and incrementally linking the others of the collection of components which must be changed in accordance with the updated declaration attribute and the updated symbol table.

7. The method of claim 1 wherein the executable object code includes function object code that implements a function and wherein step (b) includes the step of:

(b.1) creating a linkage area in the memory for holding references to the function object code;

(b.2) storing executable object code that implements the function in a function memory portion and identifying the function memory portion by a memory reference in the linkage area; and

wherein step (e) comprises the step of;

(e.3) compiling and linking calls to the function by using the memory reference in the linkage area to indirectly access the executable object code implementing the function.

8. The method of claim 7 wherein step (e) further includes the step of:

(e.4) determining whether the new executable object code fits in the memory portion specified by the object code property of the one component, and

(e.4.1) if so, storing the new executable object code in the memory portion; and

(e.4.2) if not, allocating a new memory portion and storing the new executable object code in the new memory portion; and

(e.4.2.1) if the first source code portion includes function source code, updating the linkage area to reference the new memory portion.

9. The method of claim 1 wherein step (e) further includes the steps of:

(e.5) generating a set of fixups describing fixup operations to be performed on portions of the new executable object code as part of storing the new executable object code in the memory.

10. An apparatus for use on a computer system with a memory for incrementally linking a user-modified part of a computer program with previously compiled and linked parts of the computer program, the computer program being comprised of source code stored in the memory and the apparatus comprising:

(a) means for storing in the memory a user-created model of the computer program the model comprising an ordered collection of components, each of the collection of components having a source code property referencing a portion of the source code in the memory, an object code property specifying a portion of the memory and client information identifying others of the collection of components which must be changed when the each component is changed;

(b) first means for compiling and linking the source code portions in each of the collection of components to store executable object code in the memory portions specified by the object code properties of each of the collection of components;

(c) means responsive to a user request for modifying a first portion of the source code and for identifying one of the collection of components having a source code property which references the first source code portion;

(d) means for accessing the client information of the one component to identify others of the collection of components which must be changed; and

(e) second means, responsive to the means for accessing, for concurrently compiling and linking the one component and all of the other components that must be changed to store new executable object code in the memory portions specified by the object code properties of the one component and the other components identified by the accessing means.

11. The apparatus of claim 10 wherein the source code in the modified component comprises an interface portion for communicating with the client components and an implementation portion comprising a remainder of the source code in the modified component which does not communicate with the client components and wherein the modified component includes an interface attribute, describing the interface portion, and an implementation attribute, describing the implementation portion, and wherein the user request receiving and processing means includes:

means responsive to a modification of the implementation portion for updating the implementation attribute;

means responsive to a modification of the interface portion for updating the interface attribute; and

wherein the second compiling and linking means is responsive to the interface attribute and to the implementation attribute for concurrently compiling and incrementally linking only the modified component when only the implementation portion is modified and for concurrently compiling and incrementally linking the modified component and the client components when the interface portion is modified.

12. The apparatus of claim 11 wherein the source code of the modified component comprises inline source code and the modified component further includes an inline attribute, and wherein the user request receiving and processing means includes:

means responsive to a modification of the inline source code for updating the inline attribute, and

wherein the second compiling and linking means includes;

means responsive to the inline attribute for concurrently compiling and incrementally linking the modified component and the client components when the inline source code is modified.

13. The apparatus of claim 10 further comprising:

means for relocating the new executable object code of the one component from an old memory location referenced by the object code property of the modified component to a new memory location when the new executable object code does not fit into the old memory location; and

means responsive to a relocation of the new executable object code for updating the object code property of modified component to specify the new memory location.

14. The apparatus of claim 13 wherein the new executable object code has a name and the modified component includes a declaration attribute relating the new executable object code name to the memory location holding the new executable object code and wherein the apparatus further comprises:

means responsive to a relocation of the new executable object code for updating the declaration attribute of the modified component to specify the new memory location.

15. The apparatus of claim 14 wherein the computer system includes a symbol table stored in the memory, the symbol table relating the memory location holding the new executable object code of the modified component with the new executable object code name and wherein the apparatus further comprises:

means for updating the symbol table to specify the new memory location of the new executable object code;

means for informing the client components that the declaration attribute of the modified component has been updated, and

third means for concurrently compiling and incrementally linking the client components in accordance with the updated declaration attribute and the updated symbol table.

16. The apparatus of claim 10 wherein the executable object code includes function object code that implements a function and wherein the first compiling and linking means includes:

means for creating a linkage area in the memory for holding references to the function object code;

means for storing executable object code that implements the function in a function memory portion and identifying the function memory portion by a memory reference in the linkage area; and

wherein the second compiling and linking means comprises;

means for compiling and linking calls to the function by using the memory reference in the linkage area to indirectly access the executable object code implementing the function.

17. The apparatus of claim 16 wherein the second compiling and linking means further includes:

means for determining whether the new executable object code fits in the memory location specified by the object code property of the modified component, and

means cooperating with the determining means for storing the new executable object code in the memory location when the new executable object code fits in the memory location specified by the object code property of the modified component; and

means cooperating with the determining means for allocating a new memory location and storing the new executable object code in the new memory location when the new executable object code does not fit in the memory location specified by the object code property of the modified component; and

means responsive to the inclusion of function source code in the source code of the modified component for updating the linkage area to reference the new memory location.

18. The apparatus of claim 10 wherein the second compiling and linking means further includes means for generating a set of fixups describing fixup operations to be performed on portions of the new executable object code as part of storing the new executable object code in the memory.