Apparatus and method enabling a compiled program to exactly recreate its source code

• US 5,249,275 A
• Filed: 04/30/1991
• Issued: 09/28/1993
• Est. Priority Date: 04/21/1986
• Status: Expired due to Term

• Current Assignee: Texas Instruments, Inc.
• Original Assignee: Texas Instruments, Inc.
• Inventors: Srivastava, Aditya
• Primary Examiner(s): Harrell, Robert B.
• Application Number:
  US07/696,265
• Time in Patent Office: 882 Days
• Field of Search: 395/375, 395/500, 395/700, 371/19, 364/DIG. 1, 364/DIG. 2
• US Class Current: 717/137
• CPC Class Codes: G06F 8/41 Compilation
• CPC Class Codes: G06F 9/4496 Unification in logic programming

Abstract

A computer system capable of compiling PROLOG programs appends to the compiled code information necessary to recreate the source which generated the compiled code. This allows program statements which use the original source code to be compiled. Each program statement is compiled into a separate block of code, with all statements in a procedure linked together in lists. Program statements can be compiled as they are created, and statements can be added or deleted by adding or deleting blocks of compiled code from the appropriate lists.

Claims

1. A method enabling a computer to compile source code statements of a programming language, comprising the steps of:

(a) translating a source code statement into an object code block;

(b) a compiler of the computer appending to the object code block information sufficient to exactly recreate the source code statement;

(c) linking the object code block and appended information into a list with object code and appended information for any related source code statements; and

(d) repeating steps (a) through (c) for each of the source code statements.

2. The method of claim 1, wherein step (c) comprises compiler steps of:

(c.1) creating a procedure execution frame for each procedure defined by the source code statements, each procedure execution frame have a plurality of pointers, wherein each pointer points to a list of object code blocks having a common property;

(c.2) determining which procedure execution frame corresponds to the procedure in which the source code statement belongs;

(c.3) selecting a list of object code blocks pointed to by a pointer in the determined procedure execution frame which have a common property with the source code statement; and

(c.4) inserting the object code block into the selected list.

3. A method enabling a computer to exactly recreate a source code statement, comprising the steps of:

(a) compiling the source code statement into an object code block;

(b) a compiler of the computer appending to the object code block recreation commands, wherein such recreation commands contain information sufficient, when considered in combination with the object code block, to recreate the source code statement; and

(c) executing the recreation commands and the object code block in a source code recreation mode to recreate the source code statement.

4. A method for compiling a procedure having a plurality of clauses, comprising the compiler steps of:

(a) creating a procedure execution frame having a plurality of pointers, each pointer corresponding to a preselected subset of clauses of the procedure having similar characteristics;

(b) separating compiling each clause into an object code block;

(c) attaching to each object code block information sufficient to exactly recreate the clause from which that object code block was compiled, to create a clause execution frame; and

(d) inserting each clause execution frame into a data structure which is pointed to by one of the procedure execution frame pointers.

5. The method of claim 4, wherein the data structure is a linked list.

6. The method of claim 4, wherein the procedure execution frame pointers correspond to subsets of clauses which are to be executed depending on which type of argument is passed to the procedure.

7. A method enabling a computer to compile a PROLOG program, comprising the steps of:

(a) translating source code statements into individual object code blocks;

(b) a compiler of the computer appending to the object code blocks information sufficient to exactly recreate the source code statements; and

(c) linking the object code blocks and appended information into lists with object code blocks and appended information for related source code statements.

8. The method of claim 7, wherein step (c) comprises compiler steps of:

(c.1) creating a procedure execution frame for each procedure defined by the source code statements, each procedure execution frame having a plurality of pointers, wherein each pointer points to a list of object code blocks having a common property;

(c.2) determining which procedure execution frame corresponds to the procedure in which the source code statement belongs;

(c.3) selecting a list of object code blocks pointed to by a pointer in the determined procedure execution frame which have a common property with the source code statement; and

(c.4) inserting the object code block into the selected list.

9. The method of claim 8, wherein the common property of steps (c.1) and (c.3) comprises the type of an argument passed to the procedure.

10. In a computer system for executing programs and having executable memory, the improvement comprising:

a plurality of procedure execution frames having pointers and located within the executable memory; and

a plurality of clause execution frames located within the executable memory and corresponding to said procedure execution frames, wherein each of said clause execution frames, and wherein each of said clause execution frames can be reached by following pointers starting from a procedure execution frame, wherein each of said clause execution frames contains machine executable code, and further wherein each of said clause execution frames contains machine executable code sufficient to enable exact reconstruction of source code from which the machine executable code was derived.

11. The system of claim 10, further comprising a mode of execution within said system for executing source code reconstruction statements and placing a copy of recreated source code into a preselected data structure.

12. A method enabling a computer to compile source code statements of a programming language, comprising the steps of:

(a) translating each source code statement into a block of machine executable instructions;

(b) a compiler of the computer appending to the block of machine executable instructions recreation information, wherein such recreation information is sufficient to recreate the source code statement exactly;

(c) linking each block of machine executable instructions having recreation information appended thereto into a list containing blocks of machine executable instructions and appended recreation information for any related source code statements; and

(d) executing commands indicated by said recreation information and the block of machine executable instructions in a source code recreation mode to recreate the source code statement.

13. The method of claim 12, wherein step (c) comprises:

(c.1) providing a procedure execution frame for each procedure defined by the source code statements, each procedure execution frame having a plurality of pointers, wherein each pointer points to a list of blocks of machine executable instructions having recreation information appended thereto, and wherein the blocks in each list have a selected common property; and

(c.2) inserting each block of machine executable instructions having recreation information appended thereto into a list having the selected common property.

14. A method enabling a computer to compile a PROLOG program, comprising the steps of:

(a) translating each clause into an individual object code block;

(b) a compiler of the computer appending to each object code block information sufficient to exactly recreate the source code statement from which it was translated, wherein the resulting object code block with appended information is referred to as a clause execution frame; and

(c) linking the clause execution frame into lists with clause execution frames of related source code statements.

15. The method of claim 14, wherein step (c) comprises:

(c.1) providing a procedure execution frame for each procedure defined by the source code statements, wherein a procedure is defined as a group of clauses having the same predicate name in the heads of said group of clauses, and each procedure execution frame having a plurality of pointers, wherein each pointer points to a list of clause execution frames which have arguments of the same type in the heads thereof;

(c.2) inserting the clause execution frame into a list with other clauses having the same predicate name and argument types thereas.

16. A method enabling using fully compiled code in source level symbolic debugging and incremental software development of high level languages, comprising the steps of:

(a) compiling each source code statement, said data structure having an object code block and a clause-command block;

(b) during symbolic debugging and incremental software development executing said clause-command block to create a representation exactly matching said source code statement.

17. The method of claim 16, wherein step (a) further comprises the step of writing said clause-command block in machine language.

18. The method of claim 16, wherein step (b) further comprises the step of placing said representation on a heap.

19. The method of claim 16, further comprising the step of:

(c) modifying said source code statement and said corresponding data structure by;

editing said source code statement;

compiling said edited source code into an object code block and a clause-command block; and

entering said object code block and said clause-command block into said corresponding data structure.