EP0406028A2
Expired / Lapsed
EP
⏱️ 0.0 years remaining
Incremental compiler for source code development system
Assignee: Digital Equipment Corp
•
Filing: 1990-07-02
•
Granted: —
•
Expires: 2010-07-02
Abstract
Abstract A computer-aided software development system includes programs to implement edit, compile, link and run sequences, all from memory, at very high speed. The compiler and linker operate on an incremental basis, line-by-line or increment-by-increment, so if only one line is changed in an edit session, then only that line and lines related to it need be recompiled if no other code is affected; linking is also done in a manner to save and re-use parts of link tables and link lists which are not changed from one edit session to another. Dependency analysis may be performed incrementally, without requiring the user to enter dependencies. Scanning is also done incrementally, and the resulting token lists and token tables, and lexical increment tables, are saved in memory to be used again where no changes are made. All of the linking tables are saved in memory so there is no need to generate link tables for increments of code where no changes in links are needed. The parser is able to skip lines or blocks of lines of source code which haven't been changed; for this purpose, each line of source text in the editor has a change-tag to indicate whether this line has been changed, and from this change-tag information a clean-lines table is built having a clean-lines indication for each line of source code, indicating how many clean lines follow the present line. All of the source code text modules, the token lists, symbol tables, code tables and related data saved from one compile to another are maintained in virtual memory rather than in files so that speed of operation is enhanced. Also, the object code created is maintained in memory rather than in a file, and executed from this memory image, to reduce delays. A virtual memory management arrangement for the system assures that all of the needed data modules and code is present in real memory in the phase being implemented, with a minimum of page faults and page swapping during the phase, again to enhance operating speed.
Inventors
- 👤 William M. Mckeeman
- 👤 Shota Aki
Bibliographic Details
Application Number
—
Jurisdiction
EP
Data Source
google_patents
Last Synchronized
2026-10-27 05:49
CPC Classifications
G; G06; G06F; G06F8/00; G06F8/40; G06F8/41; G06F8/48; G06F8/70; G06F8/71; G06F9/00; G06F9/06; G06F9/44; G06F9/445; G06F9/44521; G06F9/44557
Claims Analysis
Total Claims: 77
Claim 1
Independent Claim
102 words
A method of reducing turnaround time in an edit-compile-link-run cycle of a programming development system, comprising the steps of: a) editing a module of application source text, said source text being resident in a file system and held during all editing actions in virtual memory in a source text buffer including a plurality of lines; b) incrementally compiling said module of application source text to create a module of executable application code; c) incrementally linking said module of executable application code to create in memory an executable form of application program; d) executing said executable form of the application program in place.
Claim 2
Independent Claim
102 words
A method of reducing turnaround time in an edit-compile-link-run cycle of a programming development system, comprising the steps of: a) editing a module of application source text, said source text being resident in a file system and held during all editing actions in virtual memory in a source text buffer including a plurality of lines; b) incrementally compiling said module of application source text to create a module of executable application code; c) incrementally linking said module of executable application code to create in memory an executable form of application program; d) executing said executable form of the application program in place.
Claim 3
Dependent Claim
28 words
A method according to claim 1 including creating for each line in said source-text buffer an associated change-tag indicating whether the line of source text has been changed.
Claim 4
Dependent Claim
48 words
A method according to claim 1 or 2 including the step of creating a cleanlines table having, for each line of said source text, a table entry having a locator for the text of said line and an indication of the number of unmodified lines following said line.
Claim 5
Dependent Claim
25 words
A method according to claim 1, 2 or 3 wherein said steps of editing, compiling and linking are performed upon a number of said modules.
Claim 6
Independent Claim
39 words
A method according to any of claims 1 to 4 including the step of stopping either the steps of compiling, linking or executing upon detecting an error, whereby a user may correct the error via said step of editing.
Claim 7
Independent Claim
218 words
A method of developing source code, comprising the steps of: a) editing a module of source using an editor, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to produce a code image; d) running the code via said code image; e) said step of compiling including: i) generatilig an increment table where each increment represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved in said increment table from a prior version of said source-text buffer and the corresponding increment has not been changed, ii) detecting semantic increments in said source text, and for each semantic increment, checking to see if the line or lines including said statement have been changed, and, if not, skipping said semantic increment and reusing code of said code table for said skipped semantic increment; f) said step of linking including generating a link table where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating a link list.
Claim 8
Independent Claim
218 words
A method of developing source code, comprising the steps of: a) editing a module of source using an editor, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to produce a code image; d) running the code via said code image; e) said step of compiling including: i) generatilig an increment table where each increment represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved in said increment table from a prior version of said source-text buffer and the corresponding increment has not been changed, ii) detecting semantic increments in said source text, and for each semantic increment, checking to see if the line or lines including said statement have been changed, and, if not, skipping said semantic increment and reusing code of said code table for said skipped semantic increment; f) said step of linking including generating a link table where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating a link list.
Claim 9
Dependent Claim
93 words
A method according to claim 6 wherein each line in said source-text buffer has an associated change-tag indicating whether the line of source text has been changed; and including the step of generating a clean-lines table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including the step of checking said clean-lines table to see if the number of clean lines is greater than the number of lines of said semantic increment.
Claim 10
Dependent Claim
37 words
A method according to claim 6 or 7 wherein each of said steps of compiling, linking and running is halted to return an error indication if an error is detected, without completing the sequence of said steps.
Claim 11
Independent Claim
189 words
A method of developing source code, comprising the steps of: a) editing a plurality of modules of source text, said source text for each module being stored in one of a plurality of separate source-text buffers as a plurality of lines; b) compiling said source-text buffers to produce a plurality of code tables, one for each source-text buffer; c) linking items of said code tables to produce a link table; d) executing the code via said code tables and said link table; e) said step of compiling including: i) generating an increment table where each increment represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved from a prior version of said source-text buffer and the corresponding source text has not been changed, ii) detecting semantic increments in said source text, and for each semantic increment, checking to see if the line or lines of said source text corresponding to said semantic increment have been changed, and, if not, skipping said semantic increment and reusing saved code of said skipped semantic increment.
Claim 12
Independent Claim
189 words
A method of developing source code, comprising the steps of: a) editing a plurality of modules of source text, said source text for each module being stored in one of a plurality of separate source-text buffers as a plurality of lines; b) compiling said source-text buffers to produce a plurality of code tables, one for each source-text buffer; c) linking items of said code tables to produce a link table; d) executing the code via said code tables and said link table; e) said step of compiling including: i) generating an increment table where each increment represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved from a prior version of said source-text buffer and the corresponding source text has not been changed, ii) detecting semantic increments in said source text, and for each semantic increment, checking to see if the line or lines of said source text corresponding to said semantic increment have been changed, and, if not, skipping said semantic increment and reusing saved code of said skipped semantic increment.
Claim 13
Dependent Claim
78 words
A method according to claim 9 including, for each one of said source-text buffers, the step of generating a clean-lines table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including the step of checking said clean-lines table to see if the number of clean lines is greater than the number of lines of said semantic increment.
Claim 14
Dependent Claim
43 words
A method according to claim 9 or 10 wherein said compiling includes, for each one of said source-text buffers, creating a symbol table for declarative statements in said token list, each entry in the symbol table corresponding to one of said declarative statements.
Claim 15
Dependent Claim
34 words
A method according to claim 9, 10 or 11 wherein said plurality of separate source-text buffers, said plurality of code tables, said code image, and said token lists, are all maintained in virtual memory.
Claim 16
Independent Claim
48 words
A method according to any of claims 9 to 12 wherein said plurality of separate source-text buffers, said plurality of code tables, said increment tables, and said link table, are all saved in virtual memory after said step of executing and used after another said step of editing.
Claim 17
Independent Claim
181 words
A system for use in developing source code, comprising: a) means for editing a module of source text and storing said source text in a source-text buffer as a plurality of lines, each line having an associated change-tag; b) means for compiling said source-text buffer to produce a code table; c) means for linking said code table to produce a code image; d) means for running the code via said code image; e) said means for compiling including: i) means for generating an increment table where each entry represents an increment of said source text in a line, and for saving said increment table in memory, and for skipping increments for which a corresponding entry has been saved from a prior version of said source-text buffer and the corresponding increment has not been changed, ii) means for detecting semantic increments in said source code, and for each semantic increment, checking via said change-tag to see if the line or lines including said statement have been changed, and, if not skipping said semantic increment and reusing code corresponding to said semantic increment.
Claim 18
Independent Claim
181 words
A system for use in developing source code, comprising: a) means for editing a module of source text and storing said source text in a source-text buffer as a plurality of lines, each line having an associated change-tag; b) means for compiling said source-text buffer to produce a code table; c) means for linking said code table to produce a code image; d) means for running the code via said code image; e) said means for compiling including: i) means for generating an increment table where each entry represents an increment of said source text in a line, and for saving said increment table in memory, and for skipping increments for which a corresponding entry has been saved from a prior version of said source-text buffer and the corresponding increment has not been changed, ii) means for detecting semantic increments in said source code, and for each semantic increment, checking via said change-tag to see if the line or lines including said statement have been changed, and, if not skipping said semantic increment and reusing code corresponding to said semantic increment.
Claim 19
Dependent Claim
74 words
A system according to claim 14 wherein said means for compiling includes means for generating a clean-lines table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including means for checking said clean-lines table to see if the number of clean lines is greater than the number of lines of said semantic increment.
Claim 20
Independent Claim
112 words
A method of incrementally compiling code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling each line of said source text to create code tables for executable statements in said source text, said compiling including: i) generating an increment table where each entry represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved in the increment table from a prior step of compiling said source-text buffer and the corresponding lines of source text have not been changed.
Claim 21
Independent Claim
112 words
A method of incrementally compiling code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling each line of said source text to create code tables for executable statements in said source text, said compiling including: i) generating an increment table where each entry represents a lexical increment of said source text and saving said increment table in memory, and skipping lexical increments for which a corresponding increment has been saved in the increment table from a prior step of compiling said source-text buffer and the corresponding lines of source text have not been changed.
Claim 22
Dependent Claim
165 words
A method according to claim 16 wherein said step of compiling includes detecting semantic increments in said source text, and for each semantic increment, checking to see if the line or lines including said statement have been changed, and, if not, skipping, said semantic increment and reusing code of said skipped semantic increment; and wherein each line in said source-text buffer has an associated change-tag indicating whether the line of source text has been changed, and including the step of generating a clean-lines table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including the step of checking said clean-lines table to see if the number of clean lines is greater than the number of lines of said semantic increment; and including the step of checking said clean-lines table to see if the lexical increment is in a line which has not been changed.
Claim 23
Independent Claim
73 words
A method of developing source code, the steps of: a) editing a module of source text using an editor, said source text being stored in memory in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce in memory a code table; c) linking said code table to produce in memory a code image in a buffer; d) running the code from said code image in said buffer.
Claim 24
Independent Claim
73 words
A method of developing source code, the steps of: a) editing a module of source text using an editor, said source text being stored in memory in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce in memory a code table; c) linking said code table to produce in memory a code image in a buffer; d) running the code from said code image in said buffer.
Claim 25
Dependent Claim
60 words
A method according to claim 18 including the step of saving said source-text buffer, said code table, and said code image, in memory, for re-using after another said step of editing; and wherein each line of said source-text buffer has an associated change-tag to indicate whether or not said line of source code is changed in said step of editing.
Claim 26
Dependent Claim
47 words
A method according to claim 18 or 19 wherein said compiling includes generating code for said code table for executable statements and creating symbol tables in memory for declarative statements in said source text, each entry in the symbol table corresponding to one of said declarative statements.
Claim 27
Independent Claim
199 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in memory in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code from said code image in said buffer in memory; e) said step of compiling including generating said code tables for executable statements of said source text and generating in memory symbol tables for declarative statements of said source text, each entry in the symbol table corresponding to one of said declarative statements; f) said step of linking including generating a link table in memory where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating in memory a link list used in said step of running.
Claim 28
Independent Claim
199 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in memory in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code from said code image in said buffer in memory; e) said step of compiling including generating said code tables for executable statements of said source text and generating in memory symbol tables for declarative statements of said source text, each entry in the symbol table corresponding to one of said declarative statements; f) said step of linking including generating a link table in memory where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating in memory a link list used in said step of running.
Claim 29
Dependent Claim
82 words
A method according to claim 21 wherein each of said steps of compiling, linking and running is halted to return an error indication if an error is detected, without completing the sequence of said steps, but saving said source-text buffer, said code table, said symbol table and said link table in virtual memory; and wherein said source-text buffer, said code table, said symbol table, and said link table saved in virtual memory are paged in and out of real memory upon demand.
Claim 30
Dependent Claim
78 words
A method according to claim 21 wherein said source-text buffer, said code table, said symbol table, and said link table are each saved in contiguous pages in virtual memory and are paged in and out of real memory upon demand; and wherein there are a plurality of said modules of source text, and there is a source-text buffer, a code table, and a symbol table saved in contiguous pages in virtual memory for each one of said modules.
Claim 31
Dependent Claim
121 words
In a method of compiling code, the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to produce a link table; d) running the code via said code table and link table; e) said step of compiling including scanning lines of said source text to generate a table of lexical increments of said source text, and saving said lexical increment table in memory, said scanning including skipping lexical increments for which corresponding lexical increments have been saved from a prior step of scanning and related source text lines have not been changed.
Claim 32
Dependent Claim
121 words
In a method of compiling code, the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to produce a link table; d) running the code via said code table and link table; e) said step of compiling including scanning lines of said source text to generate a table of lexical increments of said source text, and saving said lexical increment table in memory, said scanning including skipping lexical increments for which corresponding lexical increments have been saved from a prior step of scanning and related source text lines have not been changed.
Claim 33
Dependent Claim
34 words
In a method according to claim 24, each line of said source-text buffer having an associated change-tag to indicate whether or not said source code has been changed since a prior step of editing.
Claim 34
Dependent Claim
29 words
A method according to claim 24 or 25 wherein said source-text buffer, said code table, said link table and said semantic increments table, are all maintained in virtual memory.
Claim 35
Independent Claim
135 words
A method of developing source code, comprising the steps of: a) editing a module of source text using an editor, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a link table in a buffer in memory; d) running the code from memory via said code table and said link table; e) said step of compiling including scanning lines of said source text to generate a table of lexical increments of said source text, and saving said lexical increment table in memory, said scanning including skipping lexical increments for which corresponding lexical increments have been saved from a prior step of scanning and related source text lines have not been changed.
Claim 36
Independent Claim
135 words
A method of developing source code, comprising the steps of: a) editing a module of source text using an editor, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a link table in a buffer in memory; d) running the code from memory via said code table and said link table; e) said step of compiling including scanning lines of said source text to generate a table of lexical increments of said source text, and saving said lexical increment table in memory, said scanning including skipping lexical increments for which corresponding lexical increments have been saved from a prior step of scanning and related source text lines have not been changed.
Claim 37
Dependent Claim
162 words
A method according to claim 27 wherein said lexical increments correspond to lines of said source code text, each line in said source-text buffer has an associated change-tag indicating whether said line has been changed, and said skipping includes reference to said change-tag wherein said source-text buffer, said code table, said link table and said table of lexical increments are all saved in virtual memory after said steps of compiling, linking and running; and including generating a clean-lines table having an entry for each of said lines of said source-text buffer, said entry including an indication of how many following lines have not been changed, and said scanning includes reference to said clean lines table; and wherein said step of compiling includes generating code to build said code table from said executable statements in said token list and generating a symbol table from declarative statements in said token list, each entry in the symbol table corresponding to one of said declarative statements.
Claim 38
Independent Claim
181 words
A method of linking, comprising the steps of: a) editing a module of source text and storing edited source text in a source-text buffer; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code via said code image; e) said step of compiling including scanning each line of said source text and generating code to build said code table for executable statements of said source text and to generate a symbol table for declarative statements in said source text; f) said step of linking including: i) generating a link table in memory where entries in said link table include an identification and location of an element needed by or supplied by said code table; ii) matching said elements needed or supplied in said link table and generating a link list; g) and, after completing or terminating said steps of compiling, linking or running, saving said link table and said link list in memory for reuse following another step of editing.
Claim 39
Independent Claim
181 words
A method of linking, comprising the steps of: a) editing a module of source text and storing edited source text in a source-text buffer; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code via said code image; e) said step of compiling including scanning each line of said source text and generating code to build said code table for executable statements of said source text and to generate a symbol table for declarative statements in said source text; f) said step of linking including: i) generating a link table in memory where entries in said link table include an identification and location of an element needed by or supplied by said code table; ii) matching said elements needed or supplied in said link table and generating a link list; g) and, after completing or terminating said steps of compiling, linking or running, saving said link table and said link list in memory for reuse following another step of editing.
Claim 40
Dependent Claim
66 words
A method according to claim 29 wherein said link list includes an entry for each one of said matched elements needed and supplied, and each said entry has a use-tag indicating whether said element was present before the current step of editing; wherein, for all of said entries for which said use-tag indicates the entry was previously present, re-using said entry in said step of linking.
Claim 41
Dependent Claim
37 words
A method according to claim 29 or 30 wherein each of said steps of compiling, linking and running is halted to return an error indication if an error is detected, without completing the sequence of said steps.
Claim 42
Independent Claim
253 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code via said code image; e) said step of compiling including scanning a representation of each line of said source text to generate code to build said code table for executable statements of said source text and to generate a symbol table for declarative statements in said source text, each entry in the symbol table corresponding to one of said declarative statements; f) said step of linking including generating a link table in memory where entries in said link table include an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating a link list used in said step of running, and including checking via said change-tag to determine if each of said entries and said link list may be reused; g) and, after completing or terminating said steps of compiling, linking or running, saving said link table and said link list in memory for reuse following another step of editing.
Claim 43
Independent Claim
253 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) compiling said source-text buffer to produce a code table in memory; c) linking said code table to produce a code image in a buffer in memory; d) running the code via said code image; e) said step of compiling including scanning a representation of each line of said source text to generate code to build said code table for executable statements of said source text and to generate a symbol table for declarative statements in said source text, each entry in the symbol table corresponding to one of said declarative statements; f) said step of linking including generating a link table in memory where entries in said link table include an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table and generating a link list used in said step of running, and including checking via said change-tag to determine if each of said entries and said link list may be reused; g) and, after completing or terminating said steps of compiling, linking or running, saving said link table and said link list in memory for reuse following another step of editing.
Claim 44
Dependent Claim
127 words
A method according to claim 32 wherein each of said steps of compiling, linking and running is halted to return an error indication if an error is detected, without completing the sequence of said steps; and wherein said step of compiling includes scanning said source text to generate a token list where each token represents a lexical increment of said source text in a line; and wherein said link list includes an entry for each one of said matched elements needed and supplied, and each said entry has a use-tag indicating whether said element was present before the current step of editing; and wherein, for all of said entries for which said use-tag indicates the entry was previously present, re-using said entry in said step of linking.
Claim 45
Independent Claim
89 words
A system for linking code, comprising: i) means for generating a link table in memory wherein entries in said link table include an identification and location of an element needed by or supplied by a code table produced by a compiler; ii) means for matching said elements needed or supplied in said link table and generating a link list; and iii) means for saving said link table and said link list in memory for reuse following another step of editing, after completing or terminating said compiling, linking or running.
Claim 46
Independent Claim
89 words
A system for linking code, comprising: i) means for generating a link table in memory wherein entries in said link table include an identification and location of an element needed by or supplied by a code table produced by a compiler; ii) means for matching said elements needed or supplied in said link table and generating a link list; and iii) means for saving said link table and said link list in memory for reuse following another step of editing, after completing or terminating said compiling, linking or running.
Claim 47
Dependent Claim
58 words
A system according to claim 34 wherein said entries of said link table includes, for each one of said elements needed and supplied, a use-tag indicating whether said element was previously present; and wherein, for all of said entries for which said use-tag indicates the entry was previously present, said entry is reused in said means for linking.
Claim 48
Dependent Claim
105 words
A system according to claim 34 or 35, including a) means for editing a module of source text and storing edited source text in a source-text buffer; b) means for compiling said source-text buffer to produce a code table in memory; c) means for linking said code table to produce a code image in a buffer in memory; d) means for running the code via said code image; e) said means for compiling including means for scanning a representation of each line of said source text to generate code for said code table for executable statements and to generate a symbol table for declarative statements.
Claim 49
Independent Claim
138 words
A method of performing an incremental dependency analysis in compiling source code, comprising the steps of: a) editing a plurality of modules of source text using an editor, said source text being stored in memory in a plurality of source-text buffers as a plurality of lines; b) performing a dependency analysis on said plurality of source-text buffers while said buffers are in memory, said dependency analysis including finding in each of said buffers in lines which have been changed statements dependent upon statements in other of said buffers to thereby select buffers which must be compiled; b) incrementally compiling said selected source-text buffers to generate or update a plurality of code tables; c) linking said code tables to produce a link table in a buffer; and d) running the code from said code tables and said link table.
Claim 50
Independent Claim
138 words
A method of performing an incremental dependency analysis in compiling source code, comprising the steps of: a) editing a plurality of modules of source text using an editor, said source text being stored in memory in a plurality of source-text buffers as a plurality of lines; b) performing a dependency analysis on said plurality of source-text buffers while said buffers are in memory, said dependency analysis including finding in each of said buffers in lines which have been changed statements dependent upon statements in other of said buffers to thereby select buffers which must be compiled; b) incrementally compiling said selected source-text buffers to generate or update a plurality of code tables; c) linking said code tables to produce a link table in a buffer; and d) running the code from said code tables and said link table.
Claim 51
Dependent Claim
102 words
A method according to claim 37 including the step of saving said source-text buffer, said code tables, and said link table, in memory, for re-using after another said step of editing; and wherein each line of each one of said plurality of said source-text buffers has an associated change-tag to indicate whether or not said source code has been changed since a prior step of editing; and wherein said compiling includes generating code for said code table for executable statements and creating symbol tables in memory for declarative statements, each entry in the symbol table corresponding to one of said declarative statements.
Claim 52
Independent Claim
229 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in memory in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) performing a dependency analysis on said plurality of source-text buffers while said buffers are in memory, said dependency analysis including finding in each of said buffers in lines which have been changed statements dependent upon statements in other of said buffers to thereby select buffers which must be compiled; c) compiling said source-text buffer to generate or update a code table in memory; d) linking said code table to produce a link table in a buffer in memory; e) running the code from said code table and said link table in said buffer in memory; f) said step of compiling including generating code to build said code table from executable statements, and including generating symbol table from declarative statements in said source-text buffer in memory; g) said step of linking including generating said link table in memory where each entry in said link table is an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table.
Claim 53
Independent Claim
229 words
A method of developing source code, comprising the steps of: a) editing a module of source text and storing edited source text in memory in a source-text buffer as a plurality of lines, each line having an associated change-tag indicating whether or not the line has been changed since a previous step of editing said module; b) performing a dependency analysis on said plurality of source-text buffers while said buffers are in memory, said dependency analysis including finding in each of said buffers in lines which have been changed statements dependent upon statements in other of said buffers to thereby select buffers which must be compiled; c) compiling said source-text buffer to generate or update a code table in memory; d) linking said code table to produce a link table in a buffer in memory; e) running the code from said code table and said link table in said buffer in memory; f) said step of compiling including generating code to build said code table from executable statements, and including generating symbol table from declarative statements in said source-text buffer in memory; g) said step of linking including generating said link table in memory where each entry in said link table is an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table.
Claim 54
Dependent Claim
91 words
A method according to claim 39 wherein each line in said source-text buffer has an associated change-tag indicating whether said line has been changed, and said skipping includes checking said change-tag; and wherein said source-text buffer, said code table, said symbol table and said link table are all saved in memory after said steps of compiling, linking and running; and including generating a clean-lines table having an entry for each of said lines of said source-text buffer, said entry including an indication of how many following lines have not been changed.
Claim 55
Independent Claim
89 words
A method of compiling code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source text to create code tables, said compiling including: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning.
Claim 56
Independent Claim
89 words
A method of compiling code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source text to create code tables, said compiling including: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning.
Claim 57
Dependent Claim
94 words
A method according to claim 41 wherein each line in said source-text buffer has an associated change-tag indicating whether the line of source text has been changed; and including the step of generating a descriptor table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including the step of check said descriptor table to see if the number of clean lines is greater than the number of lines of said a semantic increment.
Claim 58
Independent Claim
161 words
A method of developing source code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to generate a link table; d) running the code via said code table and said link table; e) said step of compiling including: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning; g) said step of linking including generating a link table where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table.
Claim 59
Independent Claim
161 words
A method of developing source code, comprising the steps of: a) editing a module of source text, said source text being stored in a source-text buffer as a plurality of lines; b) compiling said source-text buffer to produce a code table; c) linking said code table to generate a link table; d) running the code via said code table and said link table; e) said step of compiling including: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning; g) said step of linking including generating a link table where each entry in said link table includes an identification and location of an element needed by or supplied by said code table, and including matching said elements needed or supplied in said link table.
Claim 60
Dependent Claim
97 words
A method according to claim 43 wherein each line in said source-text buffer has an associated change-tag indicating whether the line of source text has been changed; and including the step of generating a descriptor table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line derived from said change-tags; and including the step of checking said descriptor table to see if the number of clean lines is greater than the number of lines of a semantic increment.
Claim 61
Independent Claim
142 words
A method of developing source code, comprising the steps of: a) editing a plurality of modules of source text, said source text for each module being stored in one of a plurality of separate source-text buffers as a plurality of lines; b) compiling said source-text buffers to produce a plurality of code tables, one for each source-text buffer; c) linking each of said code tables to produce a link table; d) running the code via said code tables and said link table; e) said step of compiling including, for each one of said source-text buffers: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning.
Claim 62
Independent Claim
142 words
A method of developing source code, comprising the steps of: a) editing a plurality of modules of source text, said source text for each module being stored in one of a plurality of separate source-text buffers as a plurality of lines; b) compiling said source-text buffers to produce a plurality of code tables, one for each source-text buffer; c) linking each of said code tables to produce a link table; d) running the code via said code tables and said link table; e) said step of compiling including, for each one of said source-text buffers: i) scanning said source text buffer to generate a table of lexical increments corresponding to lines of said source text, and, if the line of source text including a lexical increment has not been changed during said step of editing, skipping said lexical increment in said scanning.
Claim 63
Dependent Claim
78 words
A method according to claim 45 including, for each one of said source-text buffers, the step of generating a descriptor table including for each line of said source code a table entry having a locator for said line and an indication of the number of clean lines following said line; and including the step of checking said descriptor table to see if the number of clean lines is greater than the number of lines of a semantic increment.
Claim 64
Dependent Claim
104 words
A method according to claim 45 or 46 wherein said compiling includes, for each one of said source-text buffers, creating a symbol table for declarative statements in said lexical increments, each entry in the symbol table corresponding to one of said declarative statements; and wherein said plurality of separate source-text buffers, said plurality of code tables, said link table, and said lexical increment tables, are all maintained in virtual memory; and wherein said plurality of separate source-text buffers, said plurality of code tables, and said lexical increment tables, are all saved after said step of running and reused after another said step of editing.
Claim 65
Independent Claim
180 words
A method of managing a virtual memory system, said virtual memory system having a paged virtual memory, a volatile memory and a non-volatile storage, said volatile memory having much faster access than said non-volatile storage, comprising the steps of: a) storing in virtual memory a plurality of separate data modules, said modules being of variable size, each module being stored on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases each of which may perform some operation on one or more of said data modules; c) swapping pages of at least one of said data modules and pages of said code for at least one of said operating phases from said non-volatile storage to said volatile memory for execution of each of said operating phases; d) and reallocating said data modules after each one of said operating phases are performed thereon to maintain each said modules in a page or pages with no interleaved data.
Claim 66
Independent Claim
180 words
A method of managing a virtual memory system, said virtual memory system having a paged virtual memory, a volatile memory and a non-volatile storage, said volatile memory having much faster access than said non-volatile storage, comprising the steps of: a) storing in virtual memory a plurality of separate data modules, said modules being of variable size, each module being stored on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases each of which may perform some operation on one or more of said data modules; c) swapping pages of at least one of said data modules and pages of said code for at least one of said operating phases from said non-volatile storage to said volatile memory for execution of each of said operating phases; d) and reallocating said data modules after each one of said operating phases are performed thereon to maintain each said modules in a page or pages with no interleaved data.
Claim 67
Dependent Claim
42 words
A method according to claim 48 wherein said code for each of said separate phases is stored in said virtual memory on a separate page or pages of said virtual memory with no interleaved data regardless of the size of said code.
Claim 68
Dependent Claim
34 words
A method according to claim 48 or 49 used in a source-code development program, said data modules including modules of source code, said operating phases including editing, compiling, linking and running said source code.
Claim 69
Dependent Claim
108 words
A method according to claim 50 wherein said steps of compiling and linking produce object code from said source code; and wherein said object code is maintained in one of said modules; and wherein said one of said modules containing said object code is not written to a file in said non-volatile storage during said operating phases; and wherein data modules include, for each module of said source code, as separate modules: a descriptor table, a table of tokens, a symbol table, and a table of code strings; and wherein said volatile memory is real memory in said virtual memory system, and said non-volatile storage is disk storage.
Claim 70
Independent Claim
192 words
A method of executing a source-code development program using a computer having a virtual memory system, said virtual memory system having a paged virtual memory, a real memory and disk storage, comprising the steps of: a) editing a plurality of separate data modules including source-code text modules, said modules being of variable size, each module being stored in virtual memory on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases of said development program, said operating phases including phases of said editing and also compiling and linking, each of said phases performing an operation on one or more of said data modules; c) moving pages of at least one of said data modules and pages of said code for at least one of said operating phases to said real memory for execution of said operating phases; d) and reallocating said data modules and said tables after said operating phases are performed thereon to maintain each of said data modules and tables in pages with no interleaved data.
Claim 71
Independent Claim
192 words
A method of executing a source-code development program using a computer having a virtual memory system, said virtual memory system having a paged virtual memory, a real memory and disk storage, comprising the steps of: a) editing a plurality of separate data modules including source-code text modules, said modules being of variable size, each module being stored in virtual memory on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases of said development program, said operating phases including phases of said editing and also compiling and linking, each of said phases performing an operation on one or more of said data modules; c) moving pages of at least one of said data modules and pages of said code for at least one of said operating phases to said real memory for execution of said operating phases; d) and reallocating said data modules and said tables after said operating phases are performed thereon to maintain each of said data modules and tables in pages with no interleaved data.
Claim 72
Dependent Claim
92 words
A method according to claim 52 wherein said code for each of said separate phases being stored in said virtual memory on a separate page or pages of said virtual memory with no interleaved data regardless of the size of said code, said phases of operation including editing, compiling and linking generating a plurality of tables associated with each of said data modules each of which is stored in virtual memory on a page or pages with no interleaved data; and wherein said operating phases produce object code from said source code.
Claim 73
Independent Claim
172 words
A method of performing a source-code development program using a computer having a virtual memory system, said virtual memory system having a paged virtual memory, a real memory and disk storage, comprising the steps of: a) storing in virtual memory a plurality of separate data modules including source-code text modules, said modules being of variable size, each module being stored on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases of said development program, each of said phases performing some operation on one or more of said data modules; c) moving pages of at least one of said data modules and pages of said code for at least one of said operating phases to said real memory for execution of said operating phases; d) and reallocating said data modules after said operating phases are performed thereon to maintain each said modules in pages with no interleaved data.
Claim 74
Independent Claim
172 words
A method of performing a source-code development program using a computer having a virtual memory system, said virtual memory system having a paged virtual memory, a real memory and disk storage, comprising the steps of: a) storing in virtual memory a plurality of separate data modules including source-code text modules, said modules being of variable size, each module being stored on a separate page or pages of said virtual memory with no interleaved data regardless of the size of the module; b) storing in virtual memory the code for a plurality of separate operating phases of said development program, each of said phases performing some operation on one or more of said data modules; c) moving pages of at least one of said data modules and pages of said code for at least one of said operating phases to said real memory for execution of said operating phases; d) and reallocating said data modules after said operating phases are performed thereon to maintain each said modules in pages with no interleaved data.
Claim 75
Dependent Claim
51 words
A method according to claim 54 wherein said code for each of said separate phases being stored in said virtual memory on a separate page or pages of said virtual memory with no interleaved data regardless of the size of said code, said phases of operation including editing, compiling and linking.
Claim 76
Dependent Claim
17 words
A method according to claim 54 wherein said operating phases produce object code from said source code.
Claim 77
Dependent Claim
36 words
A method according to claim 54 wherein data modules include, for each module of said source code, as separate modules: a descriptor table, a table of tokens, a symbol table, and a table of code strings.
References Cited (Backward Citations)
No citation records indexed.
USPTO Annuity & Maintenance Windows
Maintenance schedule is calculated for granted US utility patents.