Method and system for translating goto-oriented procedural languages into goto-free object oriented languages

• US 6,002,874 A
• Filed: 12/22/1997
• Issued: 12/14/1999
• Est. Priority Date: 12/22/1997
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Bahrs, Peter Carl, Feigenbaum, Barry Alan
• Primary Examiner(s): Hafiz, Tariq R.
• Assistant Examiner(s): DAS, CHAMELI
• Application Number:
  US08/995,535
• Time in Patent Office: 722 Days
• Field of Search: 395/705, 395/702, 395/701, 709/302
• US Class Current: 717/157
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/427 Parsing
• CPC Class Codes: G06F 8/51 Source to source

Abstract

A method and system for translating goto-oriented procedural languages into object oriented languages. A class structure is selected into which the source program will be transformed. The class structure is selected based upon the granularity of translation. The lowest level of granularity involves the translation of each source program statement into an executable object in the resulting object oriented program. Highest level of granularity translates the entire source program into a single object in the resultant program. The transformation program causes the construction of an output program that creates instances of each object type with parameters based upon the input source program. The parameters can specify branching logic to replace goto statements and they involve generation of executable method code to implement processing logic of the procedural source program. Intermediate levels of granularity are also possible. The resulting program can be optimized to reduce memory and load times by replacing passing of statement index values with passing of the next executable object itself. Finally, dynamic loading of objects can be implemented to provide that object instances are created only as required for execution. This optimization reduces the memory requirements and speeds processing particularly in cases where significant portions of code are not executed.

Claims

1. A computer implemented method for executing a computer source program written using a GOTO procedural language in an object oriented environment that does not support GOTO control flows, the method comprising the steps of:

selecting an object oriented framework having an execution granularity;

transforming, based on said granularity, said source program written using said GOTO procedural language into a plurality of objects each having a plurality of attributes and one or more executable methods;

creating instances of said objects;

initiating object method execution by invoking a first method; and

repeatedly executing object methods in response to each previous method execution until termination is indicated, wherein each method execution returns an indicator indicating which object method to next execute.

2. The method of claim 1, wherein said object oriented framework includes an object for each of a plurality of procedural language statements, and wherein said transforming step comprises:

selecting an object type matching each procedural language statements; and

generating object initialization commands to create an instance of said selected object based on parameters of said each procedural language statement.

3. The method of claim 2, wherein said object instances are maintained in an indexed array of objects and wherein said returned indicator is an index to said indexed array.

4. The method of claim 2, wherein said returned indicator is the next object method to invoke.

5. The method of claim 2, wherein said instance creation occurs dynamically only when said object method is invoked for execution.

6. The method of claim 1, wherein said object oriented framework includes an object for each labeled paragraph of said procedural language program and wherein said transforming step comprises:

generating object definition code for said labeled paragraph containing attributes indicative of said paragraph and at least one executable method having program logic to perform the function defined in said source program;

initializing instances of labeled paragraph objects based on said object definition code;

initiating execution of a first object method;

executing object methods in response to each previously executed method, each executed method returning an indicator indicating a next labeled paragraph to execute.

7. The method of claim 1, wherein said object oriented framework contains a single object representing said source program, said single object having an executable method implementing the program logic of said source program;

and wherein said transforming step comprises;

generating object method logic based on said source program logic, wherein each statement of said source program logic becomes an indexed entry for an indexed branch instruction, and wherein control flow within said method is controlled by modifying a next index value.

8. The method of claim 1, wherein said object oriented framework contains a single object representing said source program, said single object having an executable method implementing the program logic of said source program;

and wherein said transforming step comprises;

generating object method logic based on said source program logic, wherein each block of said source program logic becomes a block of method code at an indexed entry for an indexed branch instruction, and wherein control flow within said method is controlled by modifying a next index value.

9. A computer program product having a computer readable medium having computer program logic recorded thereon for transforming procedural language source code having GOTO control flows into executable GOTO-less object oriented code, said computer program product comprising:

computer readable program product means for causing a computer to select an object oriented framework having a transformation granularity;

computer readable program product means for causing a computer to receive and parse each of a plurality of procedural language source code statements;

computer readable program product means for causing a computer to generate object definition code, including attributes and method code, in response to said object oriented framework and said parsed plurality of procedural language source code statements;

computer readable program product means for causing a computer to generate object initialization means in response to said object oriented framework and said parsed plurality of procedural language source code statements;

computer readable program product means for causing a computer to initiate method execution by invoking a first method;

computer readable program product means for causing a computer to invoke a next method ;

specified as a return from each executed method until the return is invalid.

10. The computer program product means of claim 9, wherein said object definition code defines an object for each statement type in said source, and wherein each statement of said source code is transformed into an instance of a statement object having parameters based on said source code.

11. The computer program product means of claim 10, wherein said object definition code defines a single object for each program, and wherein said method code generated for said object method includes an indexed branch statement for controlling code logic flow.

12. A system for generating executable object oriented code in response to a selected code granularity and a goto based source code program, the system comprising:

memory means for storing code;

memory means for storing an object structure representative of said selected code granularity;

means for transforming based on said granularity said source program written using said GOTO procedural language into a plurality of objects each having a plurality of attributes and one or more executable methods and

processor means for analyzing said goto based source code program and generating object oriented code definitions into said memory means in response to said selected code granularity.

13. The system of claim 12, wherein said selected code granularity causes transformation of each source code statement into an object instance having attributes based on said source code statement parameters.

14. The system of claim 13, further comprising:

execution means for initializing and executing said object oriented code definitions causing creation of object instances and execution of object methods.

15. The system of claim 14, wherein each object is loaded into said memory means only when required for object method execution.

16. The system of claim 14 wherein said execution flow is controlled by each object method returning an index to a next executable statement in the order of the procedural source code control flow.

17. The system of claim 14, wherein said execution flow is controlled by each object method returning the next object method to be executed in the order of the procedural source code control flow.

18. The system of claim 12, wherein said selected granularity causes transformation of each labeled paragraph into a paragraph object.

19. The system of claim 18, wherein said transformation creates virtual paragraphs to represent entry points internal to a paragraph.

20. The system of claim 18, wherein said transformation implements entry points internal to a paragraph by double dispatching.