Patent Grant
7357332
1. Field of the Invention
The present invention relates to a method, system, and program for providing diagnostic information on the processing of variables in source code.
2. Description of the Related Art
Programmers write computer programs in high level languages referred to as the source code which includes data declarations and instructions that operate on data. All addressing is symbolic, which means that the programmer assigns labels (names) to individual data elements and instructions to use throughout the program. Before the program can be executed, the source code must be transformed to machine readable executable code.
An assembler or compiler translates the source module into an object module, which includes machine readable executable code, data, external symbol definitions and references, address constants, and further bookkeeping information used in the process of transforming the object module into an executable file. Symbol references and address constants in one object module may reference text defined in another object module. The term “text” as defined and used herein means data and/or code. A linkage editor combines one or more object or load modules into an executable load module in preparation for execution. Typically, the linkage editor combines object modules that contain a single definition of a symbol, i.e., symbol definition, and one or more references to the symbol, i.e., symbol references. If one object module includes a reference to an external symbol defined in another object module, then the linkage editor may resolve this reference with the definition in the load module.
Certain programming languages provide extensions and enhancements implemented using macro-processors and pre-processors, referred to herein as preprocessors. A preprocessor performs a series of textual transformations on the source code before translation by the language translator, such as compilers, assemblers, interpreters, etc. A macro processor allows the programmer to define and to use macros in assembly programs. The program includes a macro definition comprising an association of code and a macro name, such that the use of the macro name in the code results in the name being substituted for the code specified in the macro definition. A preprocessor also processes the source code before the translation stage. These processors provide added generality and flexibility to the programmer.
Unlike typical high-level languages, preprocessors may have fewer constraints than higher level translators on the use of names that are specific to the macro- and preprocessing environment. These names are referred to “variable symbols”, as opposed to the symbol names used to translate the output. A preprocessor may not require that variable symbols be declared and initialized before they are referenced in statements of the preprocessor language. The lack of such declaration and initialization requirements may result in detection of a misuse of a variable symbol. Further, the preprocessor may implicitly declare the variable by assigning default properties, such as a default type, to the undeclared variable to allow translation of the source code to continue. These assigned properties in the implicit declaration may or may not be what the user desired or expected and thus cause errors in the object code resulting from the translated source code.
Assigning default properties and values to undeclared variable symbols may result in an improper value being substituted to produce unexpected results. Further, leaving a variable symbol undeclared, i.e., undefined, may lead to unexpected default values being substituted. Problems with incompatible implicit declarations and undefined variables may not be identified unless a syntax error results.
Provided are a method, system, and program for providing diagnostic information on the processing of variables in source code. Source code is scanned for an instance of a variable. An entry is added to a symbol table for the variable and indication is made in the entry that the variable is declared in response to determining that the symbol table does not include an entry for the variable and that the instance of the variable comprises a declaration of the variable. A message is generated indicating that the variable is referenced and undeclared in response to determining that the instance of the variable comprises a reference of the variable and that the symbol table does not include one entry for the variable.
a and 3b illustrate an embodiment of operations to process variable symbols when translating source code.
In the following description, reference is made to the accompanying drawings which form a part hereof and which illustrate several embodiments of the present invention. It is understood that other embodiments may be utilized and structural and operational changes may be made without departing from the scope of the present invention.
In processing the source code 12, the preprocessor 9 may generate a symbol table 16 including information on processed variable symbols in the source code 12. The preprocessor 9 may generate information on variable symbols in messages a user may observe on a user interface 18 coupled to the computer 2. The user interface 18 may comprise a display monitor presenting information from the translator 10 on the result of processing the variable symbols during the compilation/assembly process.
a and 3b illustrate operations performed by the processor 4 executing the preprocessor 9 to process the source code 12 statements as part of a preprocessing operation. With respect to
If (at block 106) the instance of the variable symbol does not comprise a declaration, but instead comprises (at block 110) an initialization of the variable symbol, then a determination is made (at block 112) as to whether there is an entry 30 in the symbol table 16 for the variable symbol in the instance. If (at block 112) there is no entry 30 in the symbol table 16, then an entry is added (at block 114) to the symbol table 16 for the variable symbol indicating that the variable is undeclared. The preprocessor 9 generates (at block 116) a message indicating that the variable is initialized and undeclared. This message may be rendered on the user interface 18 to make the user aware of this error in the source code 12 to improve diagnosing of the source code 12. The preprocessor 9 may further add (at block 118) a statement to the source code 12 comprising an implicit declaration of the variable symbol based on the value initializing the variable or the context initializing the variable. For instance, if the statement comprises the initialization of an arithmetic value then the implicit declaration may comprise a declaration of the variable symbol being initialized as an arithmetic type.
Statement (1) below is an example of initializing the variable “&E” to the arithmetic value “7”:
&E SETA 7 (1)
Upon identifying the statement (1) when the variable “&E” is not previously declared, the preprocessor 9 may add a statement to the source code 12 of “LCLA &E”, which comprises a declaration of a local arithmetic variable “&E”. These examples utilize the syntax from the International Business Machines Corporation (“IBM”) High Level assembler language as described in the IBM publication “High Level Assembler for MVS & VM & VSE, Language Reference, Release 5”, document no. SC26-4940-04 (Copyright IBM, 5th Ed., June 2004).
From block 118 or if (from the no branch of block 112) the symbol table 16 includes an entry for the variable symbol being initialized, the preprocessor 9 indicates (at block 120) in the entry 30 for the variable symbol in the symbol table 16 that the variable symbol is initialized, which in certain embodiments may involve setting the initialized flag 36. The value field 40 in the entry for the variable symbol is set (at block 122) to the value to which the variable symbol is initialized. Control then proceeds to block 132 in
If (at block 110) the instance of the variable symbol is not an initialization of the variable, then the instance of the variable symbol comprises a reference to the variable and control proceeds to block 124 in
From block 104, 108, 122 or 130, if (at block 132) there are further statements in the source code 12, then the next statement is processed (at block 134) and control proceeds to block 102 in
If a variable symbol comprises an array or dimensioned variable symbol having a plurality of elements, an entry is added to the symbol table 16 for each variable element of the dimensioned variable symbol. For instance, the statement (2) below:
LCLA &D(10) (2)
comprises a declaration of a local arithmetic dimensioned variable “&D(10)” having ten elements. The preprocessor 9 sets the entry 30 in the symbol table 16 for each element of the dimensioned variable “&D(10)” to indicate that the element is declared, such as by setting the declared flag 34 in the entries for the elements. The entries 30 for the elements of the dimensioned variable symbol are further updated to reflect initialization and/or reference to the variable symbol elements.
The described embodiments provide techniques to generate diagnostic information during the compiling or assembly process of source code 12, which may be performed by a preprocessor or macro processor, to notify a user or developer of certain anomalies in the source code, such as variable symbols referenced and/or initialized, but not declared or variable symbols declared, but not initialized and/or referenced. The diagnostic may be presented to the user on a user interface 18. Providing such diagnostic information on errors in the source code statements with respect to variable symbols improves the readability and operability of the compiled object code 14 resulting from the source code 12.
In the described embodiments, a preprocessor 9 processed variable symbols in source code to generate a message indicating that the variable symbol is referenced and undeclared in response to determining that the instance of the variable comprises a reference of the variable and that the symbol table does not include one entry for the variable. In an alternative embodiment, the operations described as performed by a preprocessor with respect to variable symbols in the source code may be performed by a compiler with respect to symbolic names the compiler must resolve to translate the output of the preprocessor into executable or interpretable code. Thus, the operations may be performed by different program processors, where a program processor comprises a preprocessor or compiler, on different types of variables, where a variable comprises a variable symbol processed by a preprocessor or a symbolic name processed by a compiler. For instance, the described embodiments may apply to scripting and text-markup languages such as GML.
The described operations may be implemented as a method, apparatus or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof. The term “article of manufacture” as used herein refers to code or logic implemented in a medium, where such medium may comprise hardware logic (e.g., an integrated circuit chip, Programmable Gate Array (PGA), Application Specific Integrated Circuit (ASIC), etc.) or a computer readable medium, such as magnetic storage medium (e.g., hard disk drives, floppy disks, tape, etc.), optical storage (CD-ROMs, optical disks, etc.), volatile and non-volatile memory devices (e.g., EEPROMs, ROMs, PROMs, RAMs, DRAMs, SRAMs, firmware, programmable logic, etc.). Code in the computer readable medium is accessed and executed by a processor. The medium in which the code or logic is encoded may also comprise transmission signals propagating through space or a transmission media, such as an optical fiber, copper wire, etc. The transmission signal in which the code or logic is encoded may further comprise a wireless signal, satellite transmission, radio waves, infrared signals, Bluetooth, etc. The transmission signal in which the code or logic is encoded is capable of being transmitted by a transmitting station and received by a receiving station, where the code or logic encoded in the transmission signal may be decoded and stored in hardware or a computer readable medium at the receiving and transmitting stations or devices. Additionally, the “article of manufacture” may comprise a combination of hardware and software components in which the code is embodied, processed, and executed. Of course, those skilled in the art will recognize that many modifications may be made to this configuration without departing from the scope of the present invention, and that the article of manufacture may comprise any information bearing medium known in the art.
The terms “an embodiment”, “embodiment”, “embodiments”, “the embodiment”, “the embodiments”, “one or more embodiments”, “some embodiments”, and “one embodiment” mean “one or more (but not all) embodiments of the present invention(s)” unless expressly specified otherwise.
The terms “including”, “comprising”, “having” and variations thereof mean “including but not limited to”, unless expressly specified otherwise.
The enumerated listing of items does not imply that any or all of the items are mutually exclusive, unless expressly specified otherwise.
The terms “a”, “an” and “the” mean “one or more”, unless expressly specified otherwise.
Further, although process steps, method steps, algorithms or the like may be described in a sequential order, such processes, methods and algorithms may be configured to work in alternate orders. In other words, any sequence or order of steps that may be described does not necessarily indicate a requirement that the steps be performed in that order. The steps of processes described herein may be performed in any order practical. Further, some steps may be performed simultaneously.
When a single device or article is described herein, it will be readily apparent that more than one device/article (whether or not they cooperate) may be used in place of a single device/article. Similarly, where more than one device or article is described herein (whether or not they cooperate), it will be readily apparent that a single device/article may be used in place of the more than one device or article.
The functionality and/or the features of a device may be alternatively embodied by one or more other devices which are not explicitly described as having such functionality/features. Thus, other embodiments of the present invention need not include the device itself.
The illustrated operations of
The foregoing description of various embodiments of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto. The above specification, examples and data provide a complete description of the manufacture and use of the composition of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5278986 | Jourdenais et al. | Jan 1994 | A |
| 5381550 | Jourdenais et al. | Jan 1995 | A |
| 5615369 | Holler | Mar 1997 | A |
| 5630137 | Carney et al. | May 1997 | A |
| 5771382 | Wang et al. | Jun 1998 | A |
| 5852731 | Wang et al. | Dec 1998 | A |
| 6106571 | Maxwell | Aug 2000 | A |
| 6182283 | Thomson | Jan 2001 | B1 |
| 6223337 | Blume | Apr 2001 | B1 |
| 6523097 | Liedtke et al. | Feb 2003 | B1 |
| 6715141 | Hodge | Mar 2004 | B1 |
| 20010034743 | Thomas | Oct 2001 | A1 |
| 20060123279 | Cardinell | Jun 2006 | A1 |
| 20060243787 | Dravnieks et al. | Nov 2006 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20060243787 A1 | Nov 2006 | US |
