Abstract:
A software development application determines whether routine name and version number parameters have been identified ( 33 ). If so, the application determines whether the specified version of the routine can be accessed ( 35 ). If the specified version cannot be accessed, the application locates a substitute version of the routine ( 37 ) and compiles and links the routines and a source file to produce an executable file ( 39 ).

Description:
FIELD OF THE INVENTION 
     The present invention relates generally to methods, devices and software applications for facilitating a development of a computer program, and has particular—but by no means exclusive—application to providing source level compatibility for the computer program. 
     BACKGROUND OF THE INVENTION 
     Software compatibility is an important aspect of the software industry. Software compatibility essentially relates to the ability of software to be used in different environments such as those provided under dissimilar operating systems. Software compatibility can be broadly divided into two categories. The first category deals with source level compatibility, which relates to allowing source code to be used in different environments. The second category deals with binary compatibility, which relates to a compiled (binary) program&#39;s ability to be executed in different environments. 
     Whilst there exists various techniques for providing source level compatibility, those techniques have significant shortcomings. For example, object versioning used with the GNU C library (glibc) involves creating a new version of the glibc library whenever an object (routine) in the library is updated such that the updated object is incompatible with early versions of the object. A new version of the glibc library creating using object versioning is such that it contains sources (code) for all versions of objects contained in the library. As a result, the glibc library can become bulky because it contains all versions of the objects. 
     Another problem closely associated with object versioning in glibc is that dynamic linkers based on object versioning tend to fail the application linking process if the available glibc library does not contain the specific version of an object that the linker requires. 
     A further example of an existing technique used to provide source level compatibility is function level versioning in HP-UX libraries. Function level versioning is similar to objecting versioning in the glibc library in that it involves creating a new library that contains all versions of a particular object. As mentioned previously, creating a new library that contains all versions of an object has the potential to produce bulky libraries. 
     SUMMARY OF THE INVENTION 
     In an embodiment of a method of facilitating a development of a computer program, the embodiment includes the step of determining whether there exists a first version of a routine that is to be incorporated into the computer program. Upon determining that the first version of the routine does not exist, the embodiment of the method proceeds to perform the step of locating a second version of the routine as a substitute for the first version to thereby facilitate the development. 
     The present invention will be more fully understood from the following description of a specific embodiment. The description is provided with reference to the accompanying figs. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  illustrates a personal computer embodying the present invention; 
         FIG. 2  is a flow chart of various steps performed by the personal computer shown in  FIG. 1 ; 
         FIG. 3  is a flow chart of various steps performed by the personal computer shown in  FIG. 1 ; and 
         FIG. 4  illustrates a data structure used by the personal computer of  FIG. 1 . 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1 . shows an embodiment of the present invention in the form of a personal computer  11 . The personal computer is made up of numerous components that cooperate with each other. The components include: a power supply; motherboard; random access memory; a video card; a monitor; keyboard; and a hard disk loaded with the Linux operating system and a software development application. In alternative embodiments of the present invention, the hard disk of the personal computer  11  is loaded with other operating systems such as, for example, Microsoft XP, SunOS and MacOS. 
     The software development application can be executed by a software developer to essentially perform two tasks that facilitate the development of a computer program. The first of the tasks relates to creating a software library that includes routines that can be used to develop a computer program. The second of the tasks relates to locating a library routine that is to be incorporated into a computer program. 
     In relation to the first task of creating the software library, the software development application can be invoked by typing at a command line prompt: cc -c file_name, where cc is the file name of the software development application, -c is an option that informs the software development application to create a linkable object file (that is, to create the software library); and file_name is the file name of the source file that is to be used to create the linkable object file. 
     Once the software development application has been invoked as specified in the preceding paragraph, the personal computer  11  executes the various instructions included in the software development application. Execution of the instructions causes the personal computer  11  to carry out the steps shown in the flow chart  21  of  FIG. 2 . With reference to  FIG. 2 , the first step  23  that the software development application performs is to obtain the source file that is identified by the file_name parameter. The source file contains at least one routine that can be incorporated into a computer program. As persons skilled in the art will readily appreciate, a software developer can create the source file using an application such as a text editor or perhaps by using a more advanced application such a software development tool. The source file is typically written in a high level language such as C or C++ so that it can be easily interpreted by software developers. 
     Subsequent to carrying out the first step  23 , the software development application proceeds to carry out the second step  25  of compiling the source file (that was obtained during the first step  23 ) to create the software library, which is in the form of linkable object code. The second step  25  of compiling the source file is such that the software library contains only a single version of any of the routines in the source file. The second step  25  of compiling the source code is such that it is capable of identifying the different versions of the routine in the source file, and placing the latest version into the library created during the compilation step  25 . Earlier versions of the routine reside in previous versions of the software library. A consequence of the second step  25  is that potentially there will be multiple versions of the software library, each of which contains a single version of the routine. An advantage of this is that unlike existing techniques for providing source level compatibility (for example, object versioning in glibc), the software library created by the second step  25  does not contain multiple version of a routine and therefore the size of the library is minimised in comparison to existing source level compatibility techniques. Whilst a software library created by the second step  25  contains a single version of a routine, this does not preclude the library from containing multiple routines, each of which performs a different function. For example, a particular library may have functions abc( ) and def( ), but the library will only contain a single version of abc( ) and def( ). 
     To ensure that each version of a software library that the previous step  25  creates, the software development application carries out the third step  27  of assigning the software library a version number. In particular, the version number is appended to a file name of the library. For example, if the file name of the library is xyz.lib the third step  27  is such that the library would have the file name xyz.lib.10 where the library is the tenth version. There would also be other versions of the library that have the file names xyz.lib.1, xyz.lib.2, xyz.lib.3 . . . xyz.lib.9. 
     In addition to the step  27  of assigning the software library the version number, the software development application also includes the fourth step  29  of assigning the version number to the routine in the software library. The version number assigned to the routine corresponds to the version number assigned to the library during the third step  27 . For instance, the routines in version 10 of a library (for example, xyz.lib.10) would be assigned the version number 10. The forth step  29  is such that it assigns the version number to the routine by assigning the version number to an entry in the software library&#39;s export table. The entry to which the version number is assigned is the entry that represents the routine. As persons skilled in the art will readily appreciate, the export table is essentially information contained in the library that enables a compiler to determine details of the various routines that are in the library. 
     Once the software library has been created it can then be used by a software developer to develop a computer program (application). As persons skilled in the art will readily appreciate the process of developing a computer program initially involves developing a source code file. The source code file can be developed by using a text editor or a more advanced software development tool. The source code file is usually written in a high level language such as C or C++. To create a binary (executable) version of the source file the software development application can be invoked to compile the source file, which includes linking the source code to the software library in the event that the source file uses one or more of the routines contained in the library. 
     To compile the source code file the software development application can be invoked by typing at a command line prompt: cc, routine_name1:vers_num1 routine_name2:vers_num2 file_name -o output_name-llib_name, where routine_name1:vers_num1 is an optional parameter that identifies the name (routine_name1) of a first routine in the software library and the version number (vers_num2) of the first routine, routine_name2:vers_num2 is a further optional parameter that identifies the name (routine_name2) of a second routine in the software library and the version number (vers_num2) of the second routine, file_name is the file name of the source code file to be compiled, -o is the name of the binary (compiled) version of the source code file, and -llib_name is the file name of the software library. It is noted that whilst the previous example of the command line contains two optional parameters that are used to identify routines in a library (routine_name1:vers_num1 and routine_name2:vers_num2), it will be readily appreciated that the command line is not restricted two parameters. For example, the command line might contain the names and version numbers of five routines in the software library. A specific example of how the software development application might be invoked is as follows: cc, abc:4 main. c -o main -lxyz, which effectively causes the software development application to compile the main.c source file into the binary file main and to resolve routine abc from version 4 of library xyz. 
     Once the software development application has been invoked as specified in the previous paragraph, the personal computer  11  executes various instructions included in the software development application. Execution of these instructions causes the personal computer  11  to carry out the steps shown in the flow chart  31  of  FIG. 3 . With reference to  FIG. 3 , the first step  33  that the software development application performs is to determine whether the routine_name:vers_num parameters have been specified. If the routine_name:vers_num parameters have not been specified, the software development application proceeds to the third step  37  (which is discussed in detail in subsequent paragraphs of this specification) to obtain the latest copy of library routines required to compile the computer program into an executable file. If, on the other hand, the routine_name:vers_num parameters have been specified, the software development application proceeds to carry out the second step  35  of determining whether a particular version (vers_num) of the routine (routine_name) can be accessed. 
     To carry out the second step  35  the software development application attempts to locate a software library on the personal computer  11  that contains the particular version of the routine. More specifically, the second step  35  involves searching for a copy of the library identified in the -llib_name parameter that has been assigned the same version number as the routine, the latter of which is identified by the vers_num parameter. To determine whether the copy of the software library is accessible, the software development application checks whether the routine version number (vers_num) is contained in the file name of the software library. For example, if the vers_num parameter is “4” and the -l parameter is “xyz”, then the second step  35  effectively involves determining whether library xyz.lib.4 exists. If it is determined that the copy of the software library is accessible, the software development application precedes to carry out the final step  39 , which is discussed in detail in subsequent paragraphs of this specification. 
     If as a result of carrying out the second step  35  the software development application is unable to locate a copy of the library (specified by the -l parameter) that contains the required version of the routine (vers_num), the software development application proceeds to carry out the third step  37  of locating a substitute version of the routine. An advantage of locating the substitute version is that unlike existing techniques for providing source level compatibility (such as that used with glibc), the software development application will not fail the linking process if it is unable to find the required version of a routine. The software development application will use the substitute version of the routine instead of the required version. It is noted, however, that use of the substitute version of the routine may cause the compiled computer program to perform in an unexpected manner. 
     To locate the substitute version of the routine, the third step  37  involves locating the latest version of the library identified by the -l parameter. This is achieved by looking for a copy of the library that has the highest version number in its file name. This assumes that version numbers are assigned in ascending order, which results in the library with the highest version number being the latest version of the library. Once the latest version of the library has been located, the third step  37  involves processing a data structure that is stored in memory and which is associated with the latest version of the library. The data structure is processed to obtain a memory address from which the routine can be retrieved. The data structure is in the form of a linked list, which provides an advantage of being able to retrieve a routine quicker than using an export table of the library. The linked list is made up of nodes, each of which points to a routine in the library. Each node also contains the name of the associated routine and the routine&#39;s version number.  FIG. 4  provides a representation of the linked list. 
     On completing the third step  37 , the software development application proceeds to carry out the final step  39  of linking the routines obtained in the preceding steps and compiling the routines with the source code file to create a binary version thereof that can be executed on a computer system.