Object-oriented method and apparatus for creating a makefile

• US 5,872,977 A
• Filed: 08/08/1997
• Issued: 02/16/1999
• Est. Priority Date: 08/08/1997
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Thompson, John Alan
• Primary Examiner(s): MacDonald, Allen R.
• Assistant Examiner(s): Stevens, Lisa
• Application Number:
  US08/908,621
• Time in Patent Office: 557 Days
• Field of Search: 395/703
• US Class Current: 717/122
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management

Abstract

A method and apparatus for building a platform dependent makefile from a platform independent "build" file. Accordingly, instead of requiring that a programmer create a plurality of makefiles for a plurality of platforms, the invention enables the programmer to create a single, platform independent build file that may be used across a plurality of platforms. The build file includes arguments that are passed to rules stored in a rules file that create an internal data structure having the information necessary for forming the makefile. The invention then uses the information in this data structure to form the platform dependent makefile.

Claims

1. A method of constructing a platform specific makefile in a computer system having a memory, the makefile having instructions for constructing an executable program, the method comprising the steps of:

A. receiving a request for constructing the makefile;

B. accessing, responsive to step A, a build file in the memory of the computer, the build file being non-plafform specific and having calls to at least one platform specific rule in a rules file, the rules file being in the memory of the computer system;

C. accessing, responsive to step B, the rules file; and

D. executing, responsive to step C, the rules called by the build file to construct the makefile.

2. The method of constructing a makefile as defined by claim 1 wherein step D comprises the further steps of:

D1. calling a makerule constructor for constructing, from the rules file and build file, a plurality of makerule instances, each makerule instance comprising a target, a dependency, and a command.

3. The method of constructing a makefile as defined by claim 2 wherein step D comprises the further step of:

D2. forming a sequential list comprising the plurality of makerule instances.

4. The method of constructing a makefile as defined by claim 3 wherein step D comprises the further step of:

D3. creating a makefile template; and

D4. entering the target, dependency, and command for each makerule instance in the list into the makefile template.

5. The method of constructing a makefile as defined by claim 1 wherein the request for constructing a makefile is transmitted from a command line in the computer system.

6. The method of constructing a makefile as defined by claim 1 wherein the build file includes initialization variables for the rules in the rules file.

7. An apparatus for constructing a platform specific makefile in a computer system having a memory, the makefile having instructions for constructing an executable program, the apparatus comprising:

a build file in the memory of the computer and being non-platform dependent;

a rules file in the memory of the computer and comprising a plurality of platform specific rules;

means for receiving a request for constructing the makefile;

first means for accessing, responsive to the receiving means, the build file, the build file having calls to at least one rule in the rules file;

second means for accessing, responsive to the first accessing means, the rules file; and

means for executing, responsive to the second accessing means, the rules called by the build file to construct the makefile.

8. The apparatus for constructing a makefile as defined by claim 7 wherein the executing means comprises:

means for forming a parsing tree from the rules file and the build file; and

means for calling a makerule constructor for constructing, from the parsing tree, a plurality of makerule instances, each makerule instance comprising a target, a dependency, and a command.

9. The apparatus for constructing a makefile as defined by claim 8 wherein the executing means further comprises:

means for forming a sequential list comprising the plurality of makerule instances.

10. The apparatus for constructing a makefile as defined by claim 9 wherein the executing means further comprises:

means for creating a makefile template; and

means for entering the target, dependency, and command for each makerule instance in the list into the makefile template.

11. The apparatus for constructing a makefile as defined by claim 7 wherein the request for constructing a makefile is transmitted from a command line in the computer system.

12. The apparatus for constructing a makefile as defined by claim 7 wherein the build file includes initialization variables for the rules in the rules file.

13. A computer program product comprising:

a computer usable medium having computer readable program code thereon for constructing a platform specific makefile in a computer system having a memory, the makefile having instructions for constructing an executable program, the computer readable program code comprising;

program code for receiving a request for constructing the makefile;

first program code for accessing, responsive to the program code for receiving, a build file in the memory of the computer, the build file being non-platform specific and having calls to at least one platform specific rule in a rules file, the rules file being in the memory of the computer system;

second program code for accessing, responsive to the first program code for accessing, the rules file; and

program code for executing, responsive to the second program code for accessing, the rules called by the build file to construct the makefile.

14. The computer program product as defined by claim 13 wherein the program code for executing comprises:

program code for forming a parsing tree from the rules file and the build file; and

program code for calling a makerule constructor for constructing, from the parsing tree, a plurality of makerule instances, each makerule instance comprising a target, a dependency, and a command.

15. The computer program product as defined by claim 14 wherein the program code for executing further comprises:

program code for forming a sequential list comprising the plurality of makerule instances.

16. The computer program product as defined by claim 15 wherein the program code for executing further comprises:

program code for creating a makefile template; and

program code for entering the target, dependency, and command for each makerule instance in the list into the makefile template.

17. The computer program product as defined by claim 13 wherein the request for constructing a makefile is transmitted from a command line in the computer system.

18. The computer program product as defined by claim 13 wherein the build file includes initialization variables for the rules in the rules file.