Patent Publication Number: US-7213238-B2

Title: Compiling source code

Description:
FIELD OF THE INVENTION 
   This invention relates to compiling source code files, and more specifically to compiling source code files having multiple occurrences of identical units of source code. 
   BACKGROUND OF THE INVENTION 
   A software template (which can be treated as a unit of source code), hereinafter called a ‘template’, is a known mechanism for reusing source code so that a software programmer can advantageously avoid rewriting or reconstructing subsequent occurrences of units of source code by using templates. Source code can include several source code files or can be a single source code file. Occurrences of a template can be found in a single source code file or in multiple source code files. A header file is usually used for defining a template. Templates are used with a computer programming language, such as C++ or ADA. However, it will be appreciated that in a generic sense a unit or source code can be repeated used in source code written in a computer programming language, such as an object oriented programming language or a structured programming language. It will be appreciated that a template can be referred by many other names, such as a “generic” in the parlance of the ADA programming language. 
   Referring to  FIG. 1 , there is depicted a compilation environment  100  for compiling a single source code file  102  having multiple occurrences of templates  104 A,  104 B, and  104 C. A compiler  106  reads source code file  102  to generate an object code file  108  corresponding to source code file  102 . Hereinafter, for the purposes of simplifying the description, the term “object code ‘of’ source code” will mean “object code ‘corresponding to’ source code”. Object file  108  includes multiple occurrences of object code  110 A,  110 B,  110 C corresponding to the multiple occurrences of templates  104 A,  104 B,  104 C respectively. The manner in which compiler  106  operates is not adequate because compilation time was used for generating identical occurrences object code  110 A,  110 B, and  110 C each corresponding to the same identical template, and storage space was used to store multiple occurrences of identical object code which is disadvantageously wasteful. 
   Generally, the prior art provides an inadequate method for compiling many source code files each having multiple occurrences of a template. Compilation time is wasted compiling the multiple occurrences of the template to generate many object code files each having multiple occurrences of identical object code of the template. In addition, the resulting generated object code files will be linked to create a bloated executable file due to the presence of the multiple occurrences of identical object code. Therefore, larger amounts of memory storage medium will be required to store the generated executable file. 
   Accordingly, a compiler which addresses, at least in part, these and other shortcomings is desired. 
   SUMMARY OF THE INVENTION 
   An object of the invention is to provide a mechanism for reducing compilation time when compiling source code files having multiple occurrences of templates. 
   The present invention provides a compilation environment for compiling source code having multiple occurrences of templates or units of identical source code. It will be appreciated that source code can include either one source code file or multiple source code files, and that multiple instances of a template can occur in either a single source code file or multiple source code files. In an embodiment, a compiler compiling source code files identifies occurrences of units of identical source code or a template. The first occurrence of the template in a source code file is noted for future reference. In a preferred embodiment, the occurrences are noted in a lookup table. An object code file is generated for a first source code file having a first occurrence of the template. However, compiling subsequent source code files to generate subsequent object code files will exclude insertion of object code for subsequent occurrences of the templates, but will instead include or insert object code of a pointer for pointing to a unit of object code corresponding to the first occurrence of the template in the first generated object code file. It will be appreciated that the compiler can be adapted to compile only a single source code file having multiple occurrences of a template. 
   In a first aspect of the invention, there is provided a compiler for compiling source code files to generate corresponding object code files, the source code files including a first source code file and a second source code file, the first source code file having an initial occurrence of a unit of source code, and the second source code file having a subsequent occurrence of the unit of source code, the compiler including means for compiling the first source code file to generate the first object code file having a first unit of object code representing the initial occurrence of the unit of source code, and means for compiling the second source code file to generate the second object code file having a pointer to the first unit of object code, whereby the pointer supplants a second unit of object code representing the subsequent occurrence of the unit of source code. 
   In a second aspect of the invention, there is provided a method for compiling source code files to generate corresponding object code files, the source code files including a first source code file and a second source code file, the first source code file having an initial occurrence of a unit of source code, and the second source code file having a subsequent occurrence of the unit of source code, the method including compiling the first source code file to generate the first object code file having a first unit of object code representing the initial occurrence of the unit of source code, and compiling the second source code file to generate the second object code file having a pointer to the first unit of object code, whereby the pointer supplants a second unit of object code representing the subsequent occurrence of the unit of source code. 
   In a third aspect of the invention, there is provided a computer program product for use in a computer system operatively coupled to a computer readable memory, the computer program product including a computer-readable data storage medium tangibly embodying computer readable program code for directing the computer to compile source code files to generate corresponding object code files, the source code files including a first source code file and a second source code file, the first source code file having an initial occurrence of a unit of source code, and the second source code file having a subsequent occurrence of the unit of source code, the computer program product including code for instructing the computer system to compile the first source code file to generate the first object code file having a first unit of object code representing the initial occurrence of the unit of source code, and code for instructing the computer system to compile the second source code file to generate the second object code file having a pointer to the first unit of object code, whereby the pointer supplants a second unit of object code representing the subsequent occurrence of the unit of source code. 
   A better understanding of these and other aspects of the invention can be obtained with reference to the following drawings and description of the preferred embodiments. 

   
     DESCRIPTION OF THE DRAWINGS 
     The embodiments of the present invention will be explained by way of the following drawings: 
       FIG. 1  depicts a compilation environment provided by the prior art; 
       FIG. 2  depicts an embodiment of a computer system for operation with various embodiments; 
       FIG. 3  depicts a compilation environment of an embodiment for use with the computer of  FIG. 2 ; 
       FIG. 2  depicts operations of the embodiment of  FIG. 3 ; 
       FIG. 7  depicts a compilation environment of a preferred embodiment for use with the computer of  FIG. 2 ; 
       FIGS. 6A ,  6 B, and  6 C depict operations of the preferred embodiment of  FIG. 5 ; 
       FIG. 7  depicts an embodiment of a table use with the embodiment of  FIG. 5 ; 
       FIG. 8  depicts a compilation environment of another preferred embodiment for use with the computer of  FIG. 2 ; 
       FIG. 9  depicts operations of the preferred embodiment as depicted in  FIG. 8 ; and 
       FIG. 10  depicts other operations of the preferred embodiment as depicted in  FIG. 8 . 
   

   DESCRIPTION OF THE PREFERRED EMBODIMENTS 
   For the purpose of simplifying the explanation of the operation of the embodiments of the invention, a software template will be described with reference to the C++ computer programming language. The invention is not limited specifically to an implementation of an embodiment of the invention in the C++ computer programming language. It will be appreciated that the embodiments of the invention are generally applicable to computer programming languages that reuse identical units of source code, or to computer languages that reuse templates or equivalents of templates, such as “generics” which are a type of template used in the ADA computer programming language. 
   In the C++ computer programming language, “specialization” refers to an occurrence of a template; informally, an occurrence of a template is also known as an “instance” of a template. The use of “occurrence” within the description does not infer that the scope of the invention is limited to the C++ computer programming language. The embodiments of the invention are not restricted to any particular type of template or computer programming language. 
   Referring to  FIG. 2 , there is depicted a computing system  200  for operation with the embodiments of the invention. A conventional computer system  202  is operationally coupled to a networked computer  214  via suitable network connections to network  212 . Network  212  is a conventional network such as a local area network, wide area network, intranets, Internet, and the like, or a convenient combination thereof. The network  212  provides a convenient mechanism for transporting data to and from the computer system  202 . It will be appreciated that embodiments of the invention can operate with computer system  202  not connected to the network  212 . Aspects of the embodiments of the invention can be distributed amongst various networked computers interacting with a computer system  204  via network  212  or a combination of networks. However, for convenient illustration and description of the embodiments of the invention, the embodiments will be implemented in computer system  202 . Computer system  202  operates with various output devices such as a display terminal  204 , a printer  208 , the network  212 , and with various input devices, such as keyboard/mouse  206  and a disk  210 . Other devices can include various computer peripheral devices, such as a scanner, CD-ROM drives, and the like. 
   Computer  202  includes a bus  416  that operationally interconnects various sub-systems or components of the computer  202 , such as a central processing unit (CPU)  218 , a memory  224 , a network interface (I/F)  222 , and an input/output interface  220 . CPU  218  may be a commercially available central processing unit suitable for operations described herein. Other variations of CPU  218  can include a plurality of CPUs. Suitable support circuits or components can be included for adapting the CPU  218  for optimum performance with the subsystems of computer  202 . Input/output (I/O) interface  220  enables communication between various subsystems of computer  202  and various input/output devices, such as keyboard/mouse  206 . Input/output interface includes a video card for operational interfacing with display unit  204 , and preferably a disk drive unit for reading suitable removable computer-readable media, such as a floppy disk  210 , or CD. Removable media  210  is a computer programmed product having programming instructions to be subsequently executed by CPU  218  to configure and enable system  202  to realize the embodiments of the invention. Media  210  can provide removable data storage if desired. Network interface  222 , in combination with a communications suite  228 , enables suitable communication between computer  202  and other computers operationally connected via network  212 . Examples of a conventional network interface can include an Ethernet card, a token ring card, a modem, or the like. Optionally, network interface  222  may also enable retrieval of transmitted programmed instructions or data to subsequently configure and enable computer  202  to realize the embodiments of the embodiments of the invention. It will be appreciated that various aspects of the embodiments of the invention can be enabled in various computer systems operationally networked to form a distributed computing environment. 
   Memory  224  is operationally coupled via bus  216  to CPU  218 . Memory  224  includes volatile and persistent memory for storage of programmed instructions of the embodiments of the invention for instructing the CPU  218 . Memory  224  also includes operating system  226  and communications suite  228 . Preferably, memory  224  includes a combination of random access memory (RAM), read-only memory (ROM), and a hard disk storage device. It will be appreciated that programmed instructions of the embodiments of the invention can be delivered to memory  224  from an input/output device, such as a floppy disk  210  insertable into a floppy disk drive via input/output interface  220 , or downloaded to memory  224  via network  212 . Operating system  226  cooperates with CPU  218  to enable various operational interfaces with various subsystems of computer  202 , and providing various operational functions, such as multitasking chores and the like. Communications suite  228  provides, through interaction with operating system  226  and network interface  222 , suitable communications protocols to enable appropriate communications with networked computing devices via network  212 , such as TCP/IP, ethernet, token ring, and the like. Memory  224  tangibly includes an embodiment  230  of the invention as will be described below. Embodiment  230  includes computer programmed instructions executable by CPU  218 , the executable instructions for instructing CPU  218  to achieve specific tasks. 
   Referring to  FIG. 3 , there is depicted a compilation environment  300  implemented as embodiment  230  of  FIG. 2 . A software programmer or a programming tool writes source code files  302 ,  306 . Source code file  302  includes a first occurrence of a template  304 A or a unit of source code. Source code file  306  includes a second or subsequent occurrence of an identical template  304 B or identical unit of source code. A compiler  308  compiles source code files  302  and  306  to generate object code files  310  and  314  respectively. Object code file  310  includes object code  312  corresponding to the first occurrence of the template  304 A. Object code file  314  includes object code of to pointer  316  for pointing to object code  312 . Rather than compiler  308  generating and inserting object code corresponding to the second occurrence of the template  304 B into file  314 , the object code corresponding to the subsequent occurrence of the template  304 B is supplanted by having the compiler  308  generate and insert object code  316  in place of the non-generated object code of the second occurrence of the template  304 B. A linker (not shown) links object code files  310  and  314  to generate an executable file (not shown). When CPU  218  of  FIG. 2  reads the object code of the pointer  316 , the address of the object code  316  is placed in a stack (not shown) and the CPU executes object code  312 . Once object code  312  has been executed, the CPU  218  retrieves from the stack the address of the object code  316  and begins execution at the appropriate location in the executable file. For subsequent occurrence of the template in the source code files, the compiler  308  generates and inserts object code of a pointer for pointing to object code  312  so that the object code of the first occurrence of the template can be executed. In a preferred embodiment, environment  300  includes table  318  for recording a usage of object code  312  corresponding to the first occurrence of the template  304 A, for recording a usage of object code  316  corresponding to a pointer for pointing to object code  312 . When compiler  308  determines a usage of a template, compiler  308  can examine table  318  to determine whether there was a prior occurrence of the template and subsequently either determine to insert object code representing a pointer into the generated object code file or determine to insert object code representing the template into the object code file. 
   Referring to  FIG. 4 , there is depicted operations  400  of compiler  308  of  FIG. 3 . All operations depicted in  FIG. 4  are performed by compiler  308  unless otherwise stated. In a preferred embodiment, computer programmed instructions tangibly embodied on a computer readable media can be used to instruct a CPU to achieve tasks embodying the operations depicted in  FIG. 2 . In S 402 , compiler  308  is ready and begins its compilation process. The algorithm follows the usual sequential compile of one file after another. In S 404 , compiler  308  examines a source code file, such as source code file  302  to locate an occurrence of a template, such as template  304 A. In S 406 , when a first occurrence of a template, such as template  304 A, is encountered, compiler  308  generates and inserts object code  312  corresponding to the first occurrence of a template  304 A into an object code file, such as object code file  310 . Compiler  308  then either examines the remainder of source code file  302  or examines another source code file  306  to locate subsequent occurrences of the template. In S 408 , when compiler  308  encounters a second occurrence of a template  304 B, compiler  308  does not generate object code for the subsequent occurrence of the template. Rather, compiler  308  generates object code  316  for pointing to the object code  312  corresponding to first occurrence of the template  304 A to supplant object code of the subsequent occurrence of the template. That is, compiler  308  generates, for each subsequent occurrence of the template in the source code files, units of object code for pointing to the object code  312 . As a result, CPU  218  of  FIG. 2  will execute the object code  312  each time CPU  218  executes the object code  316 . In S 410 , compiler  308  inserts a unit of object code  316  into object file  314  corresponding to source code file  306 . Since source code file  306  contains a subsequent occurrence of the template, object code file  314  of source code file  306  contains object code  316  to supplant what typically would have been object code corresponding to the subsequent occurrence of the template  304 B. Object code of the subsequent occurrences of the template in various source code files are not generated and inserted into other generated object code files, but rather they are supplanted by object code of pointers which are inserted into various generated object code files. In S 412 , compiler  308  ends the compilation process. 
   Referring to  FIG. 5 , there is depicted a compilation environment  500  implemented as embodiment  230  of  FIG. 2 . Compiler  512  includes computer programmed instructions that tangibly embody the operations depicted in  FIGS. 6A ,  6 B, and  6 C. Compiler  512  interacts with a table  514 . Table  514  is used for storing and retrieving usage of object code of the first occurrence of the template in an object code file, and various uses of object code of pointers (for pointing to the object code of the first of occurrence of the template) that were inserted into various object code files of the environment  500 . A preferred embodiment of table  516  is depicted as template registry  700  of  FIG. 7 , which is explained later. 
   Environment  500  includes a header file  502  defining a template  504  so that identical templates and template values can be conveniently inserted into various source code files. Source files  506  and  708  were created, for example by a computer programmer or programming tool, and are ready to be compiled by compiler  512 . Source code file  506  includes a first occurrence of a template  508 A. Source code file  510  includes a second or subsequent occurrence of the template  508 B. Compiler  512  compiles source code files  506  and  510  to generate object files  516  and  520  respectively. Object code files  516  includes a unit of object code of the first occurrence of the template  518 . Object code  522  includes a unit of object code of a pointer for pointing to the unit of object code  518 . Compiler  512  generated and inserted the unit of object code of the pointer to the first occurrence of the template  522  into object code file  520  to supplant the generation and insertion of the unit of object code representing a subsequent occurrence of the template into object code file  520 . Linker  524  links object code files  516  and  520  to generate an executable file  526 . 
   Referring to  FIGS. 6A ,  6 B, and  6 C, there is depicted operations of the compiler  512  of  FIG. 5 . It is understood that the operations depicted in  FIGS. 6A ,  6 B, and  6 C are, in the exemplary embodiment, performed by compiler  512  unless specifically stated otherwise. The compilation operation of compiler  512  begins at S 602  of  FIG. 6A . In S 604 , compiler  512  determines whether there are any source code files present in environment  500  that need to be compiled. Compiler  512  locates and identifies the source code files  506  and  510 , and begins by selecting source code file  506 . In S 606 , when source code file  506  has been identified, compiler  512  compiles the source code of source code file  506 . During compilation of the source code file, compiler  512  determines whether there is any occurrence of a template in the selected source code file (S 608 ). If there is no occurrence of any template in the source code file, then processing continues to S 618  (of  FIG. 8C ) in which case a determination is made whether to continue compilation of the remaining source code of source code file  506  or begin compilation of another source code file. If compiler  512  detects an occurrence of a template, then processing continues to S 610  of  FIG. 8B . For example, compiler  512  detects the presence of the first occurrence of a template  508 A in source code file  506  for which processing continues to S 610 . In S 610 , compiler  512  determines whether the detected occurrence of the template is a first occurrence of the template. If a first occurrence if detected, then processing continues to S 612 , else processing continues to S 620 . In operations S 612  and S 614  inclusive, compiler  512  manages a case where a first occurrence of the template is detected. In operations S 622  to S 626  inclusive, compiler  512  manages a case where subsequent occurrences of the same template are detected either in the same source code file or other source code files. 
   Referring to  FIG. 8B , once the first occurrence of the template has been detected, such as the detection of the first template in a source code file  506 , compiler  512  records a usage of the first occurrence of the template (S 612 ). Compiler  512  records the use of the first occurrence  508 A in table  514 . Consequently, in S 614 , compiler  512  creates an object code file having a unit of object code of the detected first occurrence of the template. Compiler  512  compiles source code file  506  to generate object code file  516  having a unit of object code of the first occurrence  518 . Processing continues to  FIG. 8C  above (i.e., immediately before) operations S 630 . 
   Referring to  FIG. 8C , after recording, in table  514 , the usage of the object code of the first occurrence of the template, the compiler  512  continues compiling the remaining source code of source code file  506 . In S 618 , compiler  512  determines whether to compile any remaining source code of the source code file. For example, if source code file  506  has additional source code yet to be compiled, then processing continues to S 606  in which case the remaining source code of source code file  506  is compiled. If there are subsequent occurrences of the same template in source code file  506 , then the compiler  512  will generate and insert, in the object code file  506  (the currently generating object code file), a unit of object code (for each detected subsequent occurrence of the template) having a pointer for pointing to the object code of the first occurrence of the template; otherwise, processing continues to S 604  because the remaining source code of source code file  506  has been completely compiled and another source code file can be selected for compilation. 
   Referring back to  FIG. 6A , since compiler  512  has completed compilation of the source code of source code file  506  in operation S 618 , then processing continues to operation S 604  so that subsequent occurrences of template can be detected in the other source code files. In S 604 , compiler  512  determines whether there are any other source code files yet to be compiled. Since source code file  510  has yet to be compiled, then processing continues to S 606  so that compiler  512  can compile source code file  510 . In S 606 , compiler  512  begins compiling another source code file, such as source code file  510 . In S 608 , during the compilation of source code file  510 , compiler  512  determines whether there is an occurrence of a template in the source code file. Since source code file  510  includes a second occurrence of the template  508 B, then processing continues to S 610 . 
   In S 610 , compiler  512  determines whether the detected occurrence of a template is a first occurrence of the template. Since occurrence  508 B is a second occurrence, then processing continues to S 620 . In S 620 , compiler  512  determines whether there is a subsequent occurrence of the template. Since occurrence  508 B is the second or subsequent occurrence, then processing continues to S 622 . Compiler  512  queries table  514  to determine whether the occurrence of the template was previously detected in an earlier compiled source code file. Since the use of the first occurrence of the template  508 A was recorded in table  514 , then processing continues to S 622 . In S 622 , compiler  512  records a usage of the subsequent occurrence of the template. Compiler  512  records the usage of the second occurrence of the template  508 B in table  514 . It will be appreciated that source code files  506  and  510  are not modified by compiler  512 . In S 624 , once the usage is recorded in table  514 , compiler  512  compiles the source code of source code file  510  but rather than creating and including object code of the subsequent occurrence of the template, a unit of object code of a pointer is created and included in place of what traditionally would have been the object code of the subsequent occurrence of the template. 
   Referring to  FIG. 8C , after noting the subsequent occurrence of the template  508 B, in S 626  compiler  512  generates and inserts object code of a pointer  522  into the created object code file  520 . The object code of the pointer  522  points to the object code of the first occurrence of the template  518 . Object code  522  is positioned in object code file  520  in place of the object code of the subsequent occurrence of the template that would have normally have been located in object file  520 . In S 630 , compiler  512  updates the table  514  to indicate that the object code file  520  includes object code of the pointer. If the remaining source code of source code file  510  has been completely compiled, processing continues to S 604  in which case other source code files can be selected for compilation. If all source code files have been compiled, then processing continues to S 632 . 
   Referring back to  FIG. 6A , all of the source code files have been compiled and in S 632  a linker links all the generated object files. Linker  524  links object files  516  and  520  to generate executable file  526 . In S 634 , compiler  512  stops the compilation process of compiler  512 . It is appreciated that a standard system linker can be used in S 632 . 
   Referring to  FIG. 7 , there is depicted a table  700  which is an embodiment of table  514  of  FIG. 5  or an embodiment of table  318  of  FIG. 3 . Table  700  is a database or look up table for containing records of the uses of various object code files of occurrences of a template, and uses of various subsequent object code files of pointers for pointing to object code of occurrences of templates. Table  700  includes records  702 ,  704  and  706 . Record  702  represents usage of object code of the first occurrence of a template. Records  704  and  706  represent usage of object code of a pointer for pointing to the object code of the first occurrence of the template in place of inserting object code of the subsequent occurrences of the same template. 
   Record  702  includes fields  708 ,  710 ,  712 ,  714 ,  716  and  718 . Each field provides a feature for assisting the operations of compiler  512  of  FIG. 5 . Field  708  represents a type of entry  702 . The types of entries are either ‘REFC’ to indicate the use of object code of the first occurrence of a template in an object code file, or ‘INST’ to indicate the use of object code of a pointer for pointing to the object code of the first occurrence of the template in object code files. The remaining fields  710  to  718  inclusive have lengths that are convenient for computerized reading of source code files. Field  710  represents the length of the template and an identifier of the template. The form of field  710  is a matter of convenience for diagnostic and tracking purposes. Field  712  represents the length and the name of a header file that defines the template, which is used for diagnostic or for error message reporting. Field  714  represents the length and full path name of the source code file in which uses a template. Field  716  represents the length and the full path name of the object code file of the source code file. Fields  714  and  716  are used to enhance the recompilation of source code files. Field  718  represents the line number and the column number of the location of the object code of the template, which is used for diagnostic purposes or error message reporting. 
   Referring to  FIG. 8 , there is depicted a compilation environment  800  of another preferred embodiment of the invention for updating various object code files for the case when a template is removed from a source code file which has a corresponding object code file having the object code of the first occurrence of the template. 
   Group ‘A’ represents a group of source code files ready for compilation by compiler  850 . Group ‘A’ includes source code files  802 ,  806 ,  808  each including an occurrence of a template  804 ,  808 , and  812  respectively. Compiler  850  performs the operations indicated in  FIGS. 6A ,  6 B, and  6 C to compile source code files  802 ,  806 , and  808  to generate corresponding object code files  814 ,  818 ,  822  which are shown in group ‘B’. Object code file  814  includes object code of the first occurrence of the template  804 . Object code files  818  and  822  each include object code  820  and  822  respectively of a pointer for pointing to object code  816 . When a software programmer wishes to remove the first occurrence  804  from file  802  and recompile file  802  to generate an object code file, the missing template  804  will otherwise create a problem since the object code  820  and  822  will be pointing to an entity that does not exist. 
   Referring to  FIG. 9 , there is depicted operations of compiler  850  of  FIG. 8 . It is understood that the steps of flowchart  900  are performed by the compiler  850  of  FIG. 8  unless stated otherwise. Referring to Group ‘C’ of  FIG. 8 , there is depicted the result of using the operations of flowchart  900  for the case when a template is removed from a source code file. Compiler  850  recompiles source code file  802  from which the first occurrence  804  was removed to generate object file  826  which has no object file of the first template. Compiler  850  examines table  852  to determine the source code file which uses an occurrence of the template which was removed from file  802 . Table  852  indicates that source code file  806  uses an occurrence of the template  808 . Compiler recompiles source code file  806  to generate a new corresponding object file  828  having object code of the first occurrence of the template  808  (recall that template  804  was removed from source code  802 ). Optionally, subsequent object files, such as file  832 , can be modified so that their pointers, such as pointer  834 , will point to the newly created object code of the first occurrence of the template  808 . Preferably, the format of the pointers is by name not location and since the name or identifier of the template does not change, then no change is needed to any other object file so that file  822  is not touched and file  832  is identical to file  822 . The table  852  is updated by compiler  850  to reflect the state of the object code files as depicted in Group ‘C’. 
   In S 902 , compiler  850  begins operations of flowchart  900 . A user has modified a source code file  802  by removing a template  804  from the source code file  802  (the modified source code file is not depicted). The user then proceeds to request compiler  850  to recompile the modified source code file to generate a new object code file  826  that will supersede the old object code file  814  having object code of a first occurrence of a template  816 . File  826  will not have object code of the first occurrence of the template. The compiler  850  examines table  852  and determines that object code  816  will be removed once the modified file  802  is recompiled and that there are subsequent object code of pointer that will be erroneously pointing to non-existing object code  816  once file  814  is regenerated. In S 904 , compiler  850  recompiles a source code file  802  from which a template  804  was removed to generate a new object code file  826  having no object code of the removed template. It will be appreciated that subsequent object code files  818 ,  822  each having at least one pointer  820 ,  824  for pointing to the object code  816  of the first occurrence of the template in the older object code file  814  are not useful since they point to object code  816  that no longer exists in the newly generated object code file of the modified source code file. The object code  820 ,  824  of the pointers need to be updated in the subsequently generated object code files. Upon generating the new object code file having no object code of the removed template (not depicted), in S 906  compiler  850  recompiles a subsequent source code file  806  corresponding to a subsequent object code file  818  having object code of a pointer  820  (that pointed to the object code of the first occurrence of the template that was located but removed from the old source code file) to generate a new subsequent object code file  828  having new object code  830  of the first occurrence of the template (which is located in the subsequent source code file). Preferably, the format of the pointers is by name not location and since the name or identifier of the template does not change, then no change is needed to any other object file, and file  822  is not touched and file  832  is identical to file  822 . 
   Optionally, upon generating the new object code file  828  having the object code  808  of the first occurrence of the template, in S 908  compiler  850  recompiles remaining subsequent source code files, such as file  810 , each having subsequent occurrences, such as  812 , of the template to generate corresponding remaining subsequent object code files, such as  832  each having a pointer, such as  834 , for pointing to the object code  830  of the first occurrence of the template located in the subsequent object code file  828 . It will be appreciated that the newly generated object code of the pointers are correctly pointing to the object code of the first occurrence of the template. S 910  ends operations of flowchart  900 . 
   Referring to  FIG. 10 , there is depicted other operations of another preferred embodiment as depicted in  FIG. 8 . It is understood that the steps of flowchart  1000  are performed by the compiler  850  of  FIG. 8  unless stated otherwise. The operations depicted in  FIG. 10  are an alternative to the operations depicted in  FIG. 9 . Referring to Group ‘D’ of  FIG. 8 , there depicted the result of using the operations of flowchart  1000  for the case when a template is removed from a source code file. Compiler  850  examines table  852  to determine the source code file which uses an occurrence of the template which was removed from file  802 . Table  852  indicates that source code file  806  uses an occurrence of the template  808 . Compiler recompiles source code file  806  to generate a new corresponding object file  828  having object code of the first occurrence of the template  808  (recall that template  804  was removed from source code  802 ). A new pointer  838  is located in object file  836  to replace the removed object file of the first occurrence  804 , and the object code of pointers, such as object code  848  of the subsequent object files, such as file  846 , are not changed because the pointers continue to point to object code  838 . The table  852  is updated by compiler  850  to reflect the state of the object code files as depicted in Group ‘C’. 
   In S 1002 , compiler  850  begins operations of flowchart  900 . A user modifies a first source code file  802  by removing a template  804  from the first source code file, and then requests the compiler  850  to compile the modified source code file. Upon examining table  852 , the compiler determines that object code  814  includes object code  816  which will be removed when file  802  is regenerated. In S 1004 , compiler  850  receives a request to recompile a first source code file  802  from which-a template was removed  804  (the modified source code file is not depicted). Upon receiving the request, in S 1006  compiler  850  recompiles a subsequent source code file  806  corresponding to a subsequent object code file  818  having object code  820  of a pointer (that points to object code  816  of a first occurrence of the template located in the first object code file  814  corresponding to the first source code file  802 ) to generate a new subsequent object code file  840  having object code  842  of the first occurrence of the template  808 . Upon generating the subsequent object code file  840 , in S 1008  compiler  850  recompiles the modified first source code file (not depicted) from which the template  804  was removed to generate a new object code file  836  having new object code  838  of a pointer for pointing to the object code  842  of the first occurrence of the template  808 . It will be appreciated that the remaining source code files, such as file  810 , do not have to be regenerated because they have corresponding object code files, such as code  846 , each having object code of pointers, such as code  848 , for pointing to object code  838  in the first object code file  836 . In S 1010 , compiler  850  ends operations of flowchart  1000 . 
   It will be appreciated that variations of some elements are possible to adapt the invention for specific conditions or functions. The concepts of the present invention can be further extended to a variety of other applications that are clearly within the scope of this invention. Having thus described the present invention with respect to a preferred embodiments as implemented, it will be apparent to those skilled in the art that many modifications and enhancements are possible to the present invention without departing from the basic concepts as described in the preferred embodiment of the present invention. Therefore, what is intended to be protected by way of letters patent should be limited only by the scope of the following claims.