Method and apparatus for generating executable code from object-oriented source code

Claim 3

The method of claim 1, wherein the step of modifying one or more header files includes the step of modifying one or more class definitions therein, and wherein the step of selectively recompiling includes recompiling those portions of the application program which include one or more references to class definitions that have been modified in the modified header files.

Claim 4

The method of claim 2, wherein the compiled application code is stored in an application program code file, said file having a timestamp reflecting said file's most recent modification, and wherein the method further includes the step of incrementing the timestamp without otherwise recompiling the application program code file.

Claim 5

The method of claim 2, wherein the step of selectively recompiling is carried out independent of user selection.

Claim 6

The method of claim 1, wherein the class definitions comprise a collection of symbolic names and data types, and wherein each of the procedure calls to the accessors specifies one or more of the symbolic names and data types of the class definition associated with the accessor.

Claim 7

The method of claim 1, wherein the accessors include one or more accessors for reading, writing, and addressing the object instances of the associated class definition.

Claim 8

The method of claim 1, wherein the accessors include one or more accessors for calling member functions on the object instances of the associated class definition.

Claim 9

The method of claim 1, wherein the accessors include one or more accessors for performing type conversions on the object instances of the associated class definition.

Claim 10

The method of claim 1, wherein the accessors include one or more accessors for fetching one or more constant values from the object instances of the associated class definition.

Claim 11

The method of claim 1, wherein the accessors include one or more accessors for fetching one or more size measurements from the object instances of the associated class definition.

Claim 12

The method of claim 1, wherein the accessors include one or more accessors for recording usage statistics regarding the object instances of the associated class definition.

Claim 13

The method of claim 1, wherein the accessors include one or more accessors for checking invariance regarding the object instances of the associated class definition.

Claim 16

The apparatus of claim 13, further including a code generation utility program selectively operative to invoke the compiler and the linker, wherein the utility program is further operative to determine whether the compiled application program code has previously been generated, and to avoid invoking the compiler to generate the recompiled application program code when said compiled application program code has previously been generated, even if one or more of the header file class definitions was modified after the compiled application program code was previously generated.

Claim 17

The apparatus of claim 14, further including a storage file receiving and storing the compiled application program code, said storage file having a timestamp indicating said file's most recent modification, and said utility program further being operative to increment the timestamp in the event that said utility program avoids invoking the compiler to generate the recompiled application program code.

Claim 18

The apparatus of claim 13 wherein the compiler is operative to recompile header file code in which class definitions have been modified by a user, and wherein the compiler is operative to selectively recompile those portions of the application program code which include one or more references to class definitions that have been modified in the modified header file code.

Claim 19

The apparatus of claim 16, wherein the compiler is operative to selectively recompile independent of user selection.

Claim 20

The apparatus of claim 13, wherein the class definitions comprise a collection of symbolic names and data types, and wherein each of the procedure calls to the accessors specifies one or more of the symbolic names and data types of the class definition associated with the accessor.

Claim 21

The apparatus of claim 13, wherein the accessors include one or more accessors for reading, writing, and addressing the object instances of the associated class definition.

Claim 22

The apparatus of claim 13, wherein the accessors include one or more accessors for calling member functions on the object instances of the associated class definition.

Claim 23

The apparatus of claim 13, wherein the accessors include one or more accessors for performing type conversions on the object instances of the associated class definition.

Claim 24

The apparatus of claim 13, wherein the accessors include one or more accessors for fetching one or more constant values from the object instances of the associated class definition.

Claim 25

The apparatus of claim 13, wherein the accessors include one or more accessors for fetching one or more size measurements from the object instances of the associated class definition.

Claim 26

The apparatus of claim 13, wherein the accessors include one or more accessors for recording usage statistics regarding the object instances of the associated class definition.

Claim 27

The apparatus of claim 13, wherein the accessors include one more accessors for checking invariance regarding the object instances of the associated class definition.

Claim 28

A computer program product comprising a computer-usable medium, and computer-readable program code embodied in said medium for generating executable computer code for an application program, said application program including at least one reference to one or more header files, each of the header files comprising one or more class definitions, each of said class definitions defining a class of object instances, and said application program further comprising a plurality of source code instructions, said source code instructions including one or more references to one or more object instances of the class definitions, said computer-readable program code comprising: computer-readable header file compiler code configured to cause a computer to generate compiled header file code comprising one or more accessors, each of the accessors being a procedure operative to access the object instances of an associated one of the class definitions, said computer-readable header file compiler code further configured to cause a computer to generate recompiled header file code after a header file has been modified by user; computer-readable application compiler code configured to cause a computer to generate compiled application program code corresponding to the plurality of source code instructions, said compiled application program code including one or more procedure calls to one or more of the accessors, each of said procedure calls corresponding to the one or more references in the source code instructions to one or more object instances of the class definitions, said computer-readable application compiler code further configured to cause a computer to recompile and generate recompiled application program code for only those portions of the application program which are affected by the recompiled header files; and computer-readable linker code configured to cause a computer to link the compiled header file code and the compiled application program code, and the recompiled application code if any, thereby generating the executable computer code.

Claim 29

A computer program product comprising a computer-usable medium, and computer-readable program code embodied in said medium for generating executable computer code for an application program, said application program including at least one reference to one or more header files, each of the header files comprising one or more class definitions, each of said class definitions defining a class of object instances, and said application program further comprising a plurality of source code instructions, said source code instructions including one or more references to one or more object instances of the class definitions, said computer-readable program code comprising: computer-readable header file compiler code configured to cause a computer to generate compiled header file code comprising one or more accessors, each of the accessors being a procedure operative to access the object instances of an associated one of the class definitions, said computer-readable header file compiler code further configured to cause a computer to generate recompiled header file code after a header file has been modified by user; computer-readable application compiler code configured to cause a computer to generate compiled application program code corresponding to the plurality of source code instructions, said compiled application program code including one or more procedure calls to one or more of the accessors, each of said procedure calls corresponding to the one or more references in the source code instructions to one or more object instances of the class definitions, said computer-readable application compiler code further configured to cause a computer to recompile and generate recompiled application program code for only those portions of the application program which are affected by the recompiled header files; and computer-readable linker code configured to cause a computer to link the compiled header file code and the compiled application program code, and the recompiled application code if any, thereby generating the executable computer code.

Claim 30

The computer program product of claim 26, further comprising computer-readable utility code configured to cause a computer to execute selectively the computer-readable header file compiler code, the computer-readable application compiler code, and the computer-readable linker code, wherein the computer-readable utility code is further configured to cause a computer to avoid re-generating the recompiled application program code if said compiled application program code has previously been generated even if one or more of the header file class definitions was modified after the compiled application program code was previously generated.

Claim 31

The computer program product of claim 26 wherein the computer-readable header file compiler code is configured to recompile those portions of the application program which include one or more references to class definitions that have been modified in the modified header files by user.

Claim 32

The computer program product of claim 26, wherein the computer-readable application compiler code is configured to selectively recompile independent of user selection.

Claim 37

The method of claim 31, wherein the application program and the recompiled header file bode both include a symbol table, and the step of recompiling one or more portions of the application program further includes: comparing the symbol table of the application program to the symbol table of the recompiled header file code if the timestamp of the application program is not later than the timestamp of the compiled application program code.

Claim 38

The method of claim 32, wherein the step of recompiling one or more portions of the application program further includes: recompiling all of the application program if the symbol table of the application program and the symbol table of the recompiled header file code are mismatched.

Claim 39

The method of claim 32, wherein the step of recompiling one or more portions of the application program further includes: updating the timestamp of the compiled application program code if the symbol table of the application program and the symbol table of the recompiled header file code match, whereby the application program is not recompiled.