US5854932A — Compiler and method for avoiding unnecessary reco…

Claim 1

Independent Claim 141 words

In a system for building a program executable on a computer, a method of minimizing rebuilding of the program following a revision, the method comprising the steps of: when building the program prior to the revision, compiling a source code file and at least one header file included by the source code file into an object code file; analyzing dependencies of the object code file on classes declared in the at least one header file; generating dependency data which approximates the dependencies of the object code file on the classes; detecting changes to the classes from the revision; generating change data relating to the changes to the classes; calculating an intersection of the dependency data with the change data; recompiling the source code file except when the intersection is nil and when the source code file is unchanged in the revision.

Claim 2

Dependent Claim 141 words

In a system for building a program executable on a computer, a method of minimizing rebuilding of the program following a revision, the method comprising the steps of: when building the program prior to the revision, compiling a source code file and at least one header file included by the source code file into an object code file; analyzing dependencies of the object code file on classes declared in the at least one header file; generating dependency data which approximates the dependencies of the object code file on the classes; detecting changes to the classes from the revision; generating change data relating to the changes to the classes; calculating an intersection of the dependency data with the change data; recompiling the source code file except when the intersection is nil and when the source code file is unchanged in the revision.

Claim 3

Dependent Claim 47 words

The method of claim 1 wherein the step of analyzing dependencies of the object code file on classes comprises the step of: analyzing dependencies of the object code file on searches for names in a scope of each class declared in the at least one header files.

Claim 4

Dependent Claim 45 words

The method of claim 1 wherein the step of analyzing dependencies of the object code file on classes comprises the step of: analyzing dependencies of the object code file on a shape of data for each class declared in the at least one header files.

Claim 5

Dependent Claim 48 words

The method of claim 1 wherein the step of analyzing dependencies of the object code file on classes comprises the step of: analyzing dependencies of the object code file on a shape of a virtual function table for each class declared in the at least one header files.

Claim 6

Dependent Claim 51 words

The method of claim 1 further comprising the steps of: detecting changes to statements that are outside class declarations in the at least one header file from the revision; and determining that the dependency data and the change data have a non-nil intersection if the statements are changed from the revision.

Claim 7

Dependent Claim 51 words

The method of claim 1 further comprising the steps of: detecting changes to rude areas in class declarations in the at least one header file from the revision; and determining that the dependency data and the change data have a non-nil intersection if the rude areas are changed from the revision.

Claim 8

Dependent Claim 61 words

The method of claim 1 further comprising the steps of: omitting to analyze the dependencies of the object code file on classes declared in any of the at least one header files that are included by the source code file from a code library; and always recompiling the source code file if said any header file is changed from the revision.

Claim 9

Dependent Claim 78 words

The method of claim 1 further comprising the step of: for each of the classes declared in the at least one header file, recording a set of dependency types of the object code file on the respective class including dependencies on searches for equivalent names in the scope of the respective class, a dependency on a shape of data for the respective class, and a dependency on a shape of a virtual function table for the respective class.

Claim 10

Dependent Claim 95 words

The method of claim 8 further comprising the step of: for each of the class declared in the at least one header file, recording a set of changes to the class from the revision including changes to the equivalent names in the respective class, a change to the shape of data for the respective class, and a change to the shape of the virtual function table for the respective class; and wherein the step of calculating the intersection comprises comparing the set of dependency types to the set of changes for each of the classes.

Claim 11

Dependent Claim 23 words

A computer-readable storage medium having stored thereon instructions executable in a computer for performing the steps of the method recited in claim 1.

Claim 12

Independent Claim 245 words

A system for minimizing rebuilding of a program for execution on a computer, comprising: a compiler operative to compile a source code file and any header files included by the source code file into an object code file, and to analyze at least one type of dependency of the object code file being compiled on classes declared in said header files to yield any class dependencies of the object code file on the classes; a change detector for detecting at least one type of change made to the classes to yield any class changes; a minimal rebuild engine in communication with the compiler and the change detector for receiving the class dependencies from the compiler and the class changes from the change detector, the minimal rebuild engine being operative to compare the class dependencies and the class changes to determine whether the class dependencies of the object code file intersect the class changes; and a compiler driver in communication with the compiler and the minimal rebuild engine and operative to cause the compiler to compile a plurality of source code files for first building the program, and further operative to cause recompiling by the compiler of a subset of the source code files for rebuilding the program, wherein the subset of the source code files excludes the source code files that are unchanged since first building the program and that were compiled into object code files whose class dependencies do not intersect the class changes.

Claim 13

Independent Claim 245 words

A system for minimizing rebuilding of a program for execution on a computer, comprising: a compiler operative to compile a source code file and any header files included by the source code file into an object code file, and to analyze at least one type of dependency of the object code file being compiled on classes declared in said header files to yield any class dependencies of the object code file on the classes; a change detector for detecting at least one type of change made to the classes to yield any class changes; a minimal rebuild engine in communication with the compiler and the change detector for receiving the class dependencies from the compiler and the class changes from the change detector, the minimal rebuild engine being operative to compare the class dependencies and the class changes to determine whether the class dependencies of the object code file intersect the class changes; and a compiler driver in communication with the compiler and the minimal rebuild engine and operative to cause the compiler to compile a plurality of source code files for first building the program, and further operative to cause recompiling by the compiler of a subset of the source code files for rebuilding the program, wherein the subset of the source code files excludes the source code files that are unchanged since first building the program and that were compiled into object code files whose class dependencies do not intersect the class changes.

Claim 14

Dependent Claim 65 words

The system of claim 11 wherein the change detector comprises: an automatic source code generator operative to generate source code declarations in said header files for a selected one of a group of modifications to the classes declared in said header files responsive to user input, and further operative to yield the class changes that result from modifying the classes to the minimal rebuild engine.

Claim 15

Dependent Claim 93 words

The system of claim 11 wherein the change detector comprises: means in the compiler for recording type information that represents the structure of the classes when compiling a source code file that includes the header files in which the classes are declared; and means in the compiler for comparing the type information of the classes recorded when compiling the source code files for first building the program to the type information of the classes recorded when compiling the subset of the source code files for rebuilding the program to yield the class changes.

Claim 16

Dependent Claim 75 words

The system of claim 13 wherein the change detector comprises: means in the compiler for detecting changes to the classes that are not reflected in their type information; and the minimal rebuild engine being operative to determine that the class dependencies of the object code file intersect the class changes if the object code file's class dependencies include any dependency on any of the classes having changes that are not reflected in their type information.

Claim 17

Dependent Claim 107 words

In a compiler, a method of minimizing rebuilding of an executable program, comprising the steps of: storing information indicative of any dependencies of an object module on any of a plurality of classes declared in any header files used in last compiling the object module; detecting any changes made since last compiling the object module to said any header files and to any source files that were used in last compiling the object module; and recompiling the object module except at least where said detected changes are solely to parts of said classes which are not indicated by the stored information as dependencies of the object module.

Claim 18

Dependent Claim 107 words

In a compiler, a method of minimizing rebuilding of an executable program, comprising the steps of: storing information indicative of any dependencies of an object module on any of a plurality of classes declared in any header files used in last compiling the object module; detecting any changes made since last compiling the object module to said any header files and to any source files that were used in last compiling the object module; and recompiling the object module except at least where said detected changes are solely to parts of said classes which are not indicated by the stored information as dependencies of the object module.

Claim 19

Dependent Claim 64 words

The method of claim 15 wherein the step of storing information indicative of the object module's dependence on said any classes comprises the step of omitting to store information indicative of the object module's dependence on selected classes that are deemed unlikely to change, and the method further comprises the step of: where change is detected to said selected classes, recompiling the object module.

Claim 20

Dependent Claim 75 words

The method of claim 15 wherein the step of storing information indicative of the object module's dependence on said any classes comprises the step of storing information indicative of any names searched for within each of said any classes' respective scope, and the method further comprises the step of: where said detected changes are solely to names in said any classes that are not indicated by the stored information, omitting to recompile the object module.

Claim 21

Dependent Claim 57 words

The method of claim 17 wherein the step of storing information indicative of said any names searched for in a class declaration comprises for each of said any searched for names the steps of: applying a hashing function to said each searched for name to yield a hash result; and storing information indicative of the hash result.

Claim 22

Dependent Claim 60 words

The method of claim 18 further comprising the step of: hashing a name changed in a declaration of a class to yield a hash result; comparing the hash result for the changed name to the stored information to thereby determine whether said detected changes are solely to names in said any classes that are not indicated by the stored information.

Claim 23

Dependent Claim 23 words

A computer-readable storage medium having stored thereon instructions executable in a computer for performing the steps of the method recited in claim 17.

Claim 24

Dependent Claim 96 words

The method of claim 18 wherein the step of storing information indicative of said any searched for names comprises the steps of: forming for each of said any classes an array having a plurality of entries associated one-to-one with a plurality of hash results; applying a hashing function to each of said any names searched for in said each of said any classes to yield a hash result for each of said searched for names; and storing information in the entry associated with the hash result indicative of the searched for name having the hash result.

Annuity Stage	Window Opens	Payment Deadline	Surcharge Period Until	Estimated Fee	Status
3.5 Years (Year 4)	2001-12-28	2002-06-29	2002-12-29	$2000.00	Window Closed / Lapsed
7.5 Years (Year 8)	2005-12-28	2006-06-29	2006-12-29	$3760.00	Window Closed / Lapsed
11.5 Years (Year 12)	2009-12-28	2010-06-29	2010-12-29	$7700.00	Window Closed / Lapsed

Compiler and method for avoiding unnecessary recompilation

Abstract

Inventors

Bibliographic Details

Claims Analysis

References Cited (Backward Citations)

USPTO Annuity & Maintenance Windows

Assigned Categories & Tags

Assign Category Tag