Patent Grant
8245204
1. Statement of the Technical Field
The present invention relates to computer programming language processing and more particularly to managing program function parameters using compiler directives.
2. Description of the Related Art
Both structural and functional programming languages specify the function or method mechanism through which computing logic can be compartmentalized into a manageable and reusable form. The conventional function or method (the terms are often used interchangeably) includes a prototype and a body. The prototype often specifies a function name, one or more parameter types for processing in the body, and a return type. The body, in turn, contains program statements which can act upon data local to the function, data external to the function, and data provided through the prototype interface in the form of parameters. Optionally, the body can specify a return value which can be passed out of the function to the calling logic.
Functions operate on the parameters passed into the function through the prototype structure. Consequently, the data types of the parameters can be fixed according to the function definition provided by the prototype. In this regard, where a function is to operate on a variety of different data types for the same parameters, different versions of the function must be created for use in each specific instance for a particular parameter data type. Even where a single function is configured to handle different data types for the same parameter, the logic must be duplicated within the function body and selected according to a selector parameter provided at the time of calling the function.
Notably, designing different functions to handle different data types for the same parameter can be problematic not only from the design standpoint in that different logic will be required for each data type, but also from the perspective that a developer utilizing the function will be required to maintain firm knowledge of the required data types for the parameters when calling the function externally. To overcome at least the latter problem, some modem third-generation languages provide for function overloading. Function overloading permits the end user to call a function using the desired data types as parameters to the function call without requiring the end user to maintain a firm awareness of the specified data types in the function prototype. Rather, the actual use of parameters in the function call can be recognized by the compiler as a selection of the correct version of the function to handle the data types of the actual parameters.
Nevertheless, many heavily utilized third generation programming languages do not support function overloading for several reasons, the principal reason relating to the heavy-weight nature of the implementation of function overloading. To provide some semblance of function overloading, however, some programming language implementations support type-generic macros. Type generic macros mimic functional overloading in that either compile time logic of the compiler, or run-time logic of the application can determine the data types of supplied parameters to a function to select an appropriate function to execute.
For instance, in the C programming language, the size of operator can be applied to supplied parameters in a generic macro form of the called function to detect the data types of the parameters. Using the sizeof data, an appropriate specific form of the actual function can be called. It will be recognized, however, that the run-time solution can be code intensive and can result in a performance penalty based upon the necessity to perform comparisons. More importantly, though, where two or more data types have the same size, the sizeof operator will be ineffectual in differentiating between the different data types.
In an alternative implementation, the compiler can be configured to detect a call to a generic form of the function. Referring to an internal compiler table, the compiler can detect the data types of supplied parameters to the generic function to choose an appropriate specific form of the function. Notably, to implement the latter solution, access to the logic of the compiler will be required which can inhibit the modification and management of permissible function prototype forms. Consequently, the latter solution will be ineffectual in the case where a library is to be developed by third-party vendors who do not have access to the internal compiler tables.
The present invention addresses the deficiencies of the art in respect to managing parameter processing for programmatic function calls and provides a novel and non-obvious method, system, architecture and apparatus for managing program function parameters using compiler directives. A parameter management system can include a compiler coupled to a primary symbol-type dictionary and a supplemental symbol-type dictionary containing parameter data for specific function calls of corresponding generic type functions. Notably, directive processing logic can be configured both to populate the supplemental symbol-type dictionary based upon processor directives embedded in source code, and also to substitute specific function calls for generic function calls in the source code as specified in the supplemental symbol-type dictionary.
A parameter management method can include the steps of detecting a compiler directive disposed in source code and extracting a generic function name, a specific function name and parameter data from the compiler directive. A generic function call having the generic function name can be located in the source code. Consequently, a specific function call having the specific function name can be substituted in the source code for the generic function call. Subsequently, the source code can be compiled.
In a preferred aspect of the invention, wherein the extracting step further can include extracting at least one constraining condition for the parameter data or for a return type. In this regard, the method further can include the step of enforcing the constraining condition for the parameter data. Alternatively, the method can further include the step of inserting an assertion in the source code to enforce the constraining condition for the parameter data. For instance, the method further can include the step of invoking a built-in function based upon the constraining condition. Alternatively, the method can include the step of utilizing the constraining condition to identify compiler optimizations either for the function specified by the function name, or for the function containing the function call.
Additional aspects of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. The aspects of the invention will be realized and attained by means of the elements and combinations particularly pointed out in the appended claims. It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.
The accompanying drawings, which are incorporated in and constitute part of this specification, illustrate embodiments of the invention and together with the description, serve to explain the principles of the invention. The embodiments illustrated herein are presently preferred, it being understood, however, that the invention is not limited to the precise arrangements and instrumentalities shown, wherein:
The present invention is a method, system and apparatus for parameter management using compiler directives. In accordance with the present invention, a compiler directive can be defined in program source code to specify a generic and specific form of a function associated with specific parameters further specified in the directive. During the compilation process, the compiler directive can be detected and processed to associate a symbol with the specific form of the function in a dictionary of symbols and types. Subsequently, when the generic form of the function is detected in the source code, the information in the dictionary can be used to substitute the specific form with the generic form in the source code in the course of compiling the source code into object code.
In further illustration of the principles of the present invention,
As it is well known in the art, compiler directives generally are compiler supported operations for performing pre-compilation processing. For example, in the C programming language, the “#pragma” operator supports the use of compiler directives embedded in source code. In the present invention, compiler directives can be used to specify generic function types without requiring a hard-coded table disposed within the compiler. In particular, the compiler directive 170 can be used to specify a generic and specific form of a function and associated parameters. Based upon the content of the directive 170, the directive processing logic 140 can populate a supplemental symbol-type dictionary 160 (supplemental to the general symbol-type dictionary 150 ordinarily included as part of a compilation system) with a table entry associating the parameter types with a specific form of a generic function. An exemplary compiler directive can include, for instance:
#pragma type_generic_func_def (generic_name, specific_name, return_type id0: (condition0), parameter_type1: (condition1), parameter_type2 (condition2) . . . )
In more particular illustration,
Optionally, one or more corresponding conditions 270A, 270B, 270n can be specified in association with the one or more parameter types 260A, 260B, 260n. Specifically, the values of supplied parameters for the return type 250 and the parameter types 260A, 260B, 260n can be constrained by the conditional logic of the conditions 250A, 270A, 270B, 270n. The conditional logic can be a source code expression to be evaluated at run-time, or conditional logic to be enforced during compile time. At compile time, the conditional logic can result in the logging of diagnostic information. In a preferred aspect of the invention, an “immediate” keyword” can be included in the compiler directive 200 as yet an additional constraint option. The immediate keyword can specify that the value of an associated argument must be known to the compiler during compile time. In this way, a built-in function can be supported and forced into use by the compiler directive.
Additionally, the conditions 250A, 270A, 270B, 270n can be used during an optimization phase of the compiler to improve performance of the computer program. Specifically, the constraint conditions can be used by the optimizer to aggressively exploit performance improvement opportunities. The immediate keyword enjoys a special use in this regard. Since the immediate keyword constrains a parameter to a compile-time constant, the compiler can use the immediate form of machine code instruction to operate upon the parameter. Such instructions are known to be more efficient.
Returning now to
In further illustration of the inventive arrangements,
Returning to decision block 320, if the line of source code is determined to be a type generic compiler directive, in block 330 parameter data and return type data can be extracted from the compiler directive. Moreover, conditional logic constraining the parameter data and return type data can be retrieved from the compiler directive. In block 340, the extracted data can be stored in a supplemental dictionary. Finally, if more source code lines remain to be processed as determined in decision block 350, in block 360 the next line of source code can be retrieved for processing and the process can be repeat through decision block 320.
Returning yet again to decision block 320, if in decision block 370 it is determined that the line of source code is a functional call to a generic function prototype, in block 380 the specific function associated with the parameters of the generic function call can be retrieved from the supplemental dictionary. In block 390, the generic functional call can be replaced with the specific function call. Notably, in decision block 400, if any of the parameters or the return type is constrained, in block 410, the constraining conditions can be evaluated and, to the extent required, a diagnostic report can be logged for the constraining condition. As an additional option, in block 420 an assertion corresponding to the constraining condition can be inserted into the source code to enforce the constraint at run-time.
The present invention can be realized in hardware, software, or a combination of hardware and software. An implementation of the method and system of the present invention can be realized in a centralized fashion in one computer system, or in a distributed fashion where different elements are spread across several interconnected computer systems. Any kind of computer system, or other apparatus adapted for carrying out the methods described herein, is suited to perform the functions described herein.
A typical combination of hardware and software could be a general purpose computer system with a computer program that, when being loaded and executed, controls the computer system such that it carries out the methods described herein. The present invention can also be embedded in a computer program product, which comprises all the features enabling the implementation of the methods described herein, and which, when loaded in a computer system is able to carry out these methods.
Computer program or application in the present context means any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after either or both of the following a) conversion to another language, code or notation; b) reproduction in a different material form. Significantly, this invention can be embodied in other specific forms without departing from the spirit or essential attributes thereof, and accordingly, reference should be had to the following claims, rather than to the foregoing specification, as indicating the scope of the invention.
This application is a continuation of application Ser. No. 10/942,428, filed Sep. 16, 2004, now U.S. Pat. No. 7,367,019 issued Apr. 29, 2008.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5857104 | Natarjan et al. | Jan 1999 | A |
| 5946488 | Tanguay et al. | Aug 1999 | A |
| 5956488 | Suzuki | Sep 1999 | A |
| 5999733 | Shamoto | Dec 1999 | A |
| 6006235 | Macdonald et al. | Dec 1999 | A |
| 6064818 | Brown et al. | May 2000 | A |
| 6067542 | Carino, Jr. | May 2000 | A |
| 6263493 | Ehrman | Jul 2001 | B1 |
| 6604818 | Leibman et al. | Aug 2003 | B2 |
| 6631516 | Baumgart et al. | Oct 2003 | B1 |
| 7367019 | Mak et al. | Apr 2008 | B2 |
| Number | Date | Country | |
|---|---|---|---|
| 20080104574 A1 | May 2008 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 10942428 | Sep 2004 | US |
| Child | 11967420 | US |
