System for generating software source code components
BACKGROUND OF THE INVENTION 
     This invention relates to software production systems and more particularly to such systems where certain portions of the software need to be generated several times. 
     A software system consists of several components, or modules, each performing a specific task. These components usually implement one or more functions, and/or are responsible for a certain structured piece of information that must be maintained, updated and retrieved in order for the software system, as a whole, to perform its overall task. 
     There are two categories of modules in a software system: (1) action modules that perform actions needed specifically for the task the system is designed to perform and (2) support modules that perform general data manipulation operations needed to support software modules of the first category. In a typical system, the majority of modules belong to the second, or support, category. 
     There exists a great deal of similarity between the support modules of different software systems. For example, all operating systems must, in some manner, maintain and manipulate stacks, queues and tables of items. The required operations for the manipulation of, say, a table of items are the same regardless of the items stored in the tables. However, a single operating system may be required to handle several independent tables, each containing items of different types. Also, different operating systems may manipulate different types of items, hence, requiring different tables for those items. 
     With the present state of the art in software development technology, modules of a software system are developed all from scratch. This is true in spite of the fact that most of the modules have been developed many times previously for other similar software systems. The reuse of previously developed software components is not presently possible since the existing software development tools do not allow the specification and production of generic modules. As the state of the art exists today, modules can be developed only to perform specific fixed actions on specific items of fixed type structured in a fixed format. As a result, a software module that supports, for example, a table of items of one type cannot be used to support a table of items of another type. Or, as another example, a module which employs a particular search strategy to find items in a table cannot be used if a different search strategy is desirable. Thus a need exists in the art for a system which allows the automatic generation of portions of the software according to the requirements specified by the software developers. 
     SUMMARY OF THE INVENTION 
     I have designed and developed a system that allows commonly used software components to be designed and developed only once, and reused many times in different systems with different contexts and different requirements. This is achieved by providing the capability for designers to specify a software component generically independent of the specifics of the context the component will be used in. When the module is to be integrated into a new system with the system&#39;s own specific requirements, my system automatically generates a concrete version of the module that fits the needs of the new system. 
     The system for software reuse consists of the following externally visible components: 
     1. A formal specification language that allows the specification of generic modules. 
     2. A compiler for the processing of specifications written in the specification language of item 1. 
     3. An instantiator for automatically generating many concrete software modules from the generic module, each to work in a given specific context based on the requirements of the context. 
     The logical entities manipulated by the system are called General Purpose Components (GPC). A GPC provides a collection of generic programming services. For instance, a GPC may provide all the operations and data definitions that are needed to maintain and manipulate a specific software table so as to store items of some particular type. The operations and definitions (collectively called &#34;services&#34;) that this GPC provides are generic in the sense that they only capture the essence of operations and definitions of &#34;tables&#34;, and are not specifically linked to any particular type of item nor to any particular method of manipulation. In their original form, therefore, these services cannot be used in any program. 
     These generic services, however, are made into concrete programming services by my system when the context and requirements of their intended environment are known. For example, when a programmer determines the type of items that are to be stored in a table, and passes this information to my system, a concrete or interpreted version of the GPC is automatically generated using the instantiator. This generated version of the software code looks exactly as it would if it would have been written by the programmer from scratch. This process of generating a concrete version from a generic version is called the instantiation process. 
     The same GPC can be used to instantiate a different concrete version for a different software system. Thus, my system allows for creating a software component once, and tailor-making it to suit different software systems automatically and as many times as desired. 
    
    
     BRIEF DESCRIPTION OF THE DRAWING 
     These and other objects and features, together with the operation and utilization of the present invention, will be more apparent from the illustrative embodiment shown in conjunction with the drawing in which 
     FIG. 1 is a block diagram showing my invention in a computer system, 
     FIGS. 2 through 16 show General Purpose Component (GPC) formats, 
     FIGS. 17 through 21 show formats of typical GPC usage, and 
     FIG. 22 shows an example output (generated program) of the system. 
    
    
     DETAILED DESCRIPTION 
     As discussed above, and as shown in FIG. 1, the embodiment shown is used in conjunction with general purpose computer 10, such as the VAX11/780. It should be understood that the described system can be used on any computer, including personal computers such as the AT&amp;T PC 6300. 
     Internally, the system consists of four interrelated components: a specification language which, as will be seen, enables the user to generate a General Purpose Component (GPC) specification 101, a GPC compiler 102 for the processing of the specification language, a storage area 104 for compiled GPC specifications, and an instantiator 106. 
     While not absolutely necessary, a user may find it convenient to extract from the GPC specifications the English descriptions of the GPCs, and store them in a separate data base 103 for future searching so that other users may find and use previously written GPC&#39;s. 
     The designer of a GPC uses the specification language to specify a GPC in a generic, context-insensitive fashion. The designer then stores the GPC specification in a file 101 within computer, and invokes GPC compiler 102 to process the file. This process results in the storage of the compiled GPC specification in a storage area 104. 
     The user of a GPC inserts proper invocation statements in the source program 105 being developed by the user. These invocation statements, as will be seen, cause the system first to generate appropriate program segments, and then to insert and/or amend the generated program segments to the user&#39;s program to create an expanded program 107. This expanded program is compiled by compiler 108 in the well-known manner and results in a compiled program 109, which, in turn, operates the computer. 
     THE SPECIFICATION LANGUAGE 
     Although my invention may be used with any computer language, the well-known C language will be assumed for explanation purposes. An explanation of such a language can be found in &#34;The C Programming Language&#34;, B. W. Kernighan and D. M. Rithie, 1978, which publication is hereby cited as a reference herein. In the sequel, bold face characters are used to denote language keywords; italics denote user-provided strings; curly brackets &#34;}&#34; and &#34;{&#34;, enclose optional entries; vertical bar &#34;&#34;, separates alternatives; and %{and %} are keywords used for quotation. 
     The specification language is used to write GPC specifications. Each specification consists of three major parts: a description part, a declaration part, and a definition part. The general form of a GPC specification, thus, is shown in FIG. 2. 
     Anything that precedes the first %% is called the description part 201 and is ignored by the compiling process. However, the user of my system may wish to develop templates and standards so that descriptions can be mechanically processed and stored in a catalog 103. The declaration part 203 is a list of one or more declarations. A declaration may declare a &#34;parameter&#34;, a &#34;service&#34;, or a &#34;hidden&#34;. The syntax for a parameter declaration is shown in FIG. 3, for a service declaration in FIG. 4 and for a hidden declaration in FIG. 5. 
     A parameter is something that the GPC user specifies whereas a service is something that the GPC will provide for the user. A parameter may be a type, a value (a constant such as one defining size of objects or error return codes), an option (used, for example, to choose between different algorithms), an operation (e.g., a hashing function or an error handling routine), or a prose (any text). A service may be a type, a value, an operation, or a prose. Hiddens will be explained later. 
     An identifier is a sequence of letters and digits that starts with a letter. The underscore character, &#34; -&#34; , counts as a letter. Upper and lower case letters are distinct. No more than the first twelve (12) characters are significant, although more may be used. 
     A type is any C language type that can be used in the general form 
     
         type VariableName; 
    
     Examples for a type are: &#34;int *&#34;, &#34;float&#34;, &#34;struct { int var1; long var2; }&#34;, and &#34;MyType&#34; where MyType has been previously defined as, for example: 
     
         typedef char * MyType(); 
    
     A value is any C language constant such as &#34;25&#34;, &#34;`033`&#34;, and &#34;1.9E-6&#34;. 
     An option is any sequence of characters that corresponds to one of the predefined strings valid for the option. 
     An operation is a name that is syntactically equivalent to the name of a C language function. It has a type, cast. 
     A prose is a name of a text segment. 
     A hidden is a service that is not accessible by the user, but may be needed by one, or more, of the user-accessible services. 
     Examples of declarations are shown in FIG. 6. 
     The implementation part 205 of the GPC specification consists of one program for each declared service or hidden. The program instructs instantiator 106 what it must do when a call to the corresponding service is found in the user programmer&#39;s code. For example, the very simple program shown in FIG. 13 defines the actions of instantiator 106 in the situation where a call to the service &#34;node&#34; is detected. It instructs the instantiator 106 to define a C language type, and to name it whatever name the user specified for the service &#34;node&#34;. The exact definition of the type depends on the linking strategy (singly or doubly) selected by the user. 
     The phrase &#34;requires Always&#34; states that, whenever &#34;node&#34; is instantiated, instantiator 106 must first make sure that another service, the one called &#34;Always&#34;, has been already instantiated. 
     The optional phrase `requires identifier` may be repeated more than once each time with a different value for identifier. Here an identifier must be the name of a hidden or another service. 
     There are only three instructions replace, header, and append, and one flow control construct if-then-else-endif. 
     Instructions are executed in the same sequence they are written except, of course, when they are grouped by the if-then-else-endif constructs. 
     The replace instruction has the general form shown in FIG. 8. When the replace instruction is executed, instantiator 106 replaces the text of the call by the given C language segment. The text of the call for an operation is the starting dollar sign, the name of the service, the ending dollar sign, and the left and right parentheses together with what is in-between. For other services, the text of the call is the name of the service and the enclosing pair of dollar signs. For obvious reasons, this instruction is not allowed for hiddens. 
     During the replacing process, all the characters in a C language segment are transferred to the output unchanged except for the following cases: 
     A sequence of the form $Name$ is transformed into $Name$. (This allows specifying GPCs in terms of other GPCs.) 
     A sequence of the form $Name$ is taken to be a reference (not a service call) to a service with the generic name &#34;Name&#34;, and is simply transformed into the user defined name for that service. 
     A sequence of the form $0$ is transformed into the user-known name of the service whose program is being specified. 
     For operation services of type operation, a sequence of the form $n$, where n is a number between 1 and 20, is taken to be a reference to the (expanded) text of the nth argument of the service call; the sequence is transformed into the corresponding string. Notice that arguments of a service call may themselves be service calls. 
     The append instruction has the general form shown in FIG. 9. When this instruction is executed, instantiator 106 appends the given C language segment to the (current) end of the user source file. The transformations of $n$ and $Name$ strings are also performed on the C language segment. If qualifier multiple is present, the C language segment is appended every time a service call is processed; if once is present, or if there is no qualifier at all, the C language segment is appended at most once. 
     The header instruction has the general form shown in FIG. 10. When this instruction is executed, instantiator 106 inserts the given C language segment in the user source file at the location of the corresponding GPC request line (or after the last inserted C language segment of other header instructions of the same GPC). The processing of the C language segments are as described above. 
     The if-then-else-endif control flow construct has the general forms shown in FIG. 11. In the form 1101, the &#34;instructions&#34; are executed if and only if &#34;condition&#34; is true. In the form 1102, the instructions between keywords then and else are executed if and only if &#34;condition&#34; is true, and instructions between keywords else and endif are executed if and only if &#34;condition&#34; is not true. An if-then-else-endif construct is syntactically equivalent to an instruction and, therefore, can appear within the if- or else-block of another if-then-else-endif construct. The endif ambiguity is resolved by connecting an endif with the last encountered if. 
     A &#34;condition&#34; has the general forms shown in FIG. 12. &#34;Identifier&#34; is the generic name of a service or a parameter. Forms 1201 and 1202 test whether the user has overridden the default value of the given parameter or service; if the user has specified a value different from the default, the first condition is true (and the second is false), otherwise the first condition is false (and the second is true). 
     Forms 1203 and 1204 test the value of the given parameter or service against the given string; &#34;==&#34; denotes equality and &#34;!=&#34; denotes inequality. 
     In the example of FIG. 13, line 1302 instructs instantiator 106 to replace the user-known name of this service by the content of the segment enclosed in the pair %{and %}. In this case, the replacing text is simply the user-known name itself (designated by $0$); that is, this instruction is indeed an &#34;echo&#34; instruction. 
     Instruction 1303 uses the if-then-else-endif construct to divide the control flow into two paths corresponding to whether the option SINGLY is requested by the user or not. The difference is in how the type with generic name &#34;node&#34; is defined. In either case, there is only one instruction, a header instruction, that has to be executed by instantiator 106. The result of performing a header instruction is to insert in the user file the given segment at the line in which the GPC was requested. $Data$ and $node$ refer to the user names for the parameter &#34;data&#34;, and the service &#34;node&#34;, respectively. The qualifier once indicates that the insertion of the segment must be done at most once no matter how many times the service &#34;node&#34; is called. Once is the default value which can be overridden by the qualifier multiple. 
     Recall that there was another class of objects that could be mentioned in a GPC&#39;s declaration part, namely those declared as hidden. A hidden is a service that the user programmer is not aware of, but that is used to implement one or more of the other services or hiddens. The instantiation of a hidden is always invoked by means of the requires mechanism. In our example, the program for the hidden &#34;Always&#34; declared in line 606 is shown in FIG. 14. 
     An interesting feature of the GPC specification language corresponds to how services of type operation can be utilized. A GPC designer may specify an operation that takes a C language segment as one of its parameters. For example, the designer may specify the operation &#34;forall&#34; that takes a list, a name to represent data in each element of the list, and a segment of code as its parameters, and executes the segment for all elements in the list from the first to the last. The specification of such an operation may be as shown in FIG. 16. 
     The Compiler 
     GPC Compiler 102 is responsible for translating a GPC specification into a format suitable for the instantiator 106. It reads a GPC specification and checks to make sure it is syntactically sound. The checks performed by the GPC Compiler include: 
     All statements in the specification are syntactically correct. 
     Every declared service and hidden is properly defined. 
     There is no dependency loops. If a service or hidden requires the instantiation of another service or hidden, the latter does not requires the instantiation of the former directly or indirectly via a chain of requires commands. 
     If GPC Compiler detects any anomalies, it so informs the GPC designer by printing error messages. Otherwise, it constructs a symbol table and a parse tree in the well-known manner similar to other compilers, and stores them in the storage area for compiled GPCs 104. This information will later be used by instantiator 106 to generate expanded programs 107. 
     It must be noted that the GPC Compiler does not generate machine code as is generally the case with ordinary compilers. The output of the GPC Compiler, instead, is an encoded (binary) representation of the specification which, as will be seen later, is used by the instantiator to generate program segments. 
     Use of GPC&#39;s 
     A user programmer about to start the implementation of a new software program searches the GPC catalog 103 looking for GPC(s) that can be used in the program to be developed. If found, the user programmer inserts &#34;request line&#34;s in the program naming the GPC(s) needed, and providing information regarding the context in which each GPC will operate. These request lines may be thought of as &#34;indirect&#34; statements since they will not be passed to compiler 108, whereas, statements that are passed to compiler 108 unchanged can be thought of as direct statements. 
     In a typical GPC request line, the user specifies the values of parameters as well as the names by which the services are to be known. A GPC request line has the general form shown in FIG. 17. 
     Args is a comma-separated list of &#34;argument-name=argument-value&#34; pairs that corresponds to parameters and services of the GPC. 
     Assuming that the GPC is called &#34;listhndlr,&#34; FIGS. 18 and 19 show two GPC request lines. 
     In the first case (FIG. 18), &#34;MyElementType&#34; is assumed to be the name of a type previously defined by the user by means of the typedef construct of C language. The GPC will provide, among other services, the definition of a type called &#34;MyListType,&#34; and an operation called &#34;ADD.&#34; In the second case (FIG. 19), the definition of &#34;data&#34; is taken to be that of the given structure, and the services provided by the GPC are called by their default names. 
     The user may assume that the services provided by listhndlr are properly defined, and are available for use anywhere in the compilation module after the GPC request line. The user can use the services by &#34;service calls&#34;. A service is called by mentioning its user-known name enclosed in a pair of dollar signs ($). For instance, FIG. 20 (corresponding to the GPC request line in FIG. 18) calls the services &#34;list&#34; and &#34;addafter&#34;. 
     As an example, let us assume that the user wants to use the listhndlr GPC in a program that reads one name per input line, and prints the names and their relative positions in the input stream in a reversed order: first name entered is printed last. The corresponding user source program may look like the program shown in FIG. 21. Note that lines 2109 through 2116 form a GPC request line, and lines 2119, 2125, 2129, 2132, 2134, 2135, and 2136 each contains a GPC service call. 
     The Instantiator 
     Instantiator 106 is responsible for generating tailor-made programs or program segments according to both the (compiled) GPC specification and the requirements of the GPC request line. Instantiator 106 first scans the user source program 105 searching for any GPC request lines. If found, it extracts the name of the GPC and locates the corresponding (compiled) specification in the compiled GPC storage area 104. Instantiator 106 then binds the values specified by the user to the generic parameters declared by the GPC designer. This results in a concrete version of the GPC specification in which all generic parameters have concrete values associated with them. 
     The above process is performed once for each GPC requested even if there are several requests for the same GPC (note that a user may request the same GPC several times, each time with a different set of values for the generic parameters). 
     Instantiator 106 also scans the user source program searching for any service calls. If a service call is located, instantiator 106 consults its internal tables to determine which GPC has the definition of the service. It then locates the definition (which, in general, is in terms of generic parameters) as well as the corresponding values for the generic parameters, and executes the definition statement by statement. This may result in changing parts of the user program, substituting parts of the user program with program segments, inserting program segments in different sections of the user program, or generating completely new programs and appending them to the user program. The exact nature of these actions, of course, is determined by the corresponding definition of the service in the GPC specification. 
     Finally, instantiator 106 creates an expanded file 107, and stores in that file the resulting generated source program 107. 
     The output (expanded program 107, FIG. 1) of instantiator 106 corresponding to the program of FIG. 21 is shown in FIG. 22. Notice that instantiator 106 has changed the source file in several ways. It has assembled two typedef phrases, and has inserted them at the line the GPC was requested. A line containing &#34;#include &lt;memory.h&gt;&#34; has been added (line 2209). All service calls in the user source file have been replaced. In particular, note that for the operations &#34;PUSH&#34; and &#34;POP&#34; complete programs have been created and added to the user code (lines 2243 to 2262 and lines 2263 to 2274, respectively), whereas operations &#34;GET,&#34; &#34;TOP,&#34; &#34;isempty,&#34; and &#34;howmany&#34; are simply replaced by program segments (lines 2229, 2233, 2236, 2238, 2239, and 2240). 
     The expanded program (FIG. 22) is now the same as it would have been if the user wanted to take the time and effort to design and write the source program in its entirety from scratch. However, since GPC&#39;s need only be designed once for a given family of modules, it can be assumed that the designer can afford to take the time to create a well-designed module thereby resulting in very efficient source code. Another aspect of the reusable GPC modules is the reduction of overall software production costs such as reduction of debugging time, reduction in code modification time as well as reduction in code writing time for subsequent uses. 
     Other Applications of the System 
     The system described here can also be used in applications other than software reuse described so far. In fact, any application in which variations of a generic component must be produced to fit specific needs can benefit from my invention. 
     To utilize my system in such applications, one uses the GPC specification language to design a generic component, and then uses the instantiator to generate many specific versions of the component. 
     As an illustrative example, consider the case where a bank wants to send letters to its customers regarding their credit standings. In such a situation, a GPC designer may specify a &#34;general purpose letter&#34; with such generic parameters as the name of the customer, whether the customer is an individual or a company, the length of time the customer has been with the bank, the customer&#39;s present and past credit standings, a variable reflecting the current policy of the bank, etc. 
     Different personalized letters are composed by the instantiator depending on the combination of all values assigned to these generic parameters for each customer. 
     For instance, different compositions of the letter may be generated for customers with satisfactory present but unsatisfactory past credit standing, and customers with satisfactory credit standings both present and past. 
     The possibilities are limitless and, depending on how sophisticated the corresponding GPC is specified, may range from a few standard formats to a large variety of truly personalized compositions all using the same general purpose letter.