System for numerical description of computer program logic

Abstract

An improved system of numerical description "in-the-large" of a program logic is used for global analysis of long-lived programs needed for perfective maintenance, including program enhancing and program reusing. Documentation "in-the-large" comprises linear program circuits, each circuit consisting of at least three non-routine logical parts consecutively following each other. A program circuit is individually numbered and its data-processing task is semantically described, creating a linear data flow (LDF). Documentation "in-the-large" is developed from the immediate environment of each logical part, this environment being represented by a numerical description of all links of this part with neighboring logical parts.

Claims

What is claimed is:

1. A machine for describing a logical structure of a large computer program, the machine comprising

a) an input device, connected to the machine, and capable of entering into a processing unit of the machine a collection of informational words, numerically describing links between routine and non-routine portions of the computer program, each portion being called a "logical part", each link representing a transfer of control of data processing action from an exit of one logical part to an entrance of another logical part; each informational word containing attributes of an exit of one logical part, which are a number and a name of a logical part, an exit number, and, optionally, a program line number of an exit, containing attributes of an entrance of a linked logical part, which are a number and a name of this logical part, an entrance number (0), and a label of an entrance line, containing attributes of a linear data flow (LDF), which are an LDF number, a starting LDF logical part, a last LDF logical part, and LDF name, the LDF attributes being specified only for those words, which link two non-routine logical parts, said collection of informational words being called a "parent collection";

b) said processing unit having an algorithm of memorizing the entered parent collection and performing a search of informational words by attributes of a logical part and by attributes of an LDF;

c) an output device, connected to the machine, and capable of providing a hard copy printout of informational words arranged in a consecutive order of non-routine logical parts which belong to a particular linear data flow.

2. A machine for describing a logical structure of a large computer program, the machine comprising

a) an input device, connected to the machine, and capable of entering into a processing unit of the machine a collection of informational words, numerically describing links between different portions of the computer program, said portions being called "logical parts", each link representing a transfer of control of data processing action from an exit of one logical part to an entrance of another logical part; each informational word containing attributes of an exit of one logical part, which are a number and a name of a logical part, an exit number, and, optionally, a program line number of an exit, containing attributes of an entrance of a linked logical part, which are a number and a name of this logical part, an entrance number (0), and a label (number) of an entrance line, attributes of a linear data flow (LDF), which are an LDF number, a starting LDF logical part, a last LDF logical part, and LDF name, the LDF attributes being specified only in those words, which link two non-routine logical parts, said collection of informational words being called a "parent collection";

b) said processing unit having an algorithm of memorizing said entered parent collection, and performing a search of informational words by attributes of a logical part and by attributes of an LDF;

c) an output device, connected to the machine, and capable of providing a hard copy printout of informational words arranged in consecutive order of non-routine logical parts and subroutines logical parts which belong to a particular linear data flow.

3. A method, performed by a computer, for numerical description of a logical structure of a large computer program, the method comprising the steps of

a) dissecting a computer program into formal logical parts, each part starting with an entrance line to which control is transferred from another logical part of the program, and each part ending at a line which precedes the entrance line of the following logical part, each part belonging to one of two classes: (1) class of subroutine logical parts which end with a RETURN-like command, and (2) class of non-routine parts which do not have a RETURN-like command;

b) next, declaring a name which defines a function of a logical part and therefore transforming a formal logical part into a functional logical part;

c) next, describing a link between two logical parts by an informational word which contains two addresses: (1) an address of an exit of one logical part, which is defined by a part number, a part name, an exit number, and, optionally, by a label of exit line, (2) an address of an entrance of a linked logical part, which is defined by a linked part number and name, by an entrance number, which is 0 (zero), and by a label of entrance line;

d) next, entering attributes of each informational word into a computer memory, creating a sequential collection of informational words, where each word is identified by an order number in said collection, said order number being called a "memory number";

e) next, conducting a computerized search for informational words, containing a particular logical part, printing out these words in a consecutive order of exit numbers of this particular part, this printout being called an "immediate environment";

f) next, creating a graph (map) of all linked non-routine logical parts, using as a source an immediate environment of each logical part,

g) next, declaring from said graph a succession of at least three consecutive non-routine logical parts, said succession starting from a part in the beginning of a program and ending at the end of the program, this succession being called a linear data flow diagram (LDF), and being identified by LDF requisites, which include a LDF number, a starting LDF part, a last LDF part;

h) next, declaring all subsequent LDFs, each LDF starting from a branching logical part, which already belongs to a declared LDF, and ending at a last LDF part, to which belongs a part ending a program, a branching part from which at least two separate LDFs start, a rooting part, at the entrance of which several LDFs meet;

i) next, assigning a name to each LDF, which describes LDF function;

j) next, amending all informational words, which describe links between non-routine logical parts, to include a number of LDF, to which a logical part belongs, whereby creating a new collection of informational words, describing both-logical parts and LDFs.

4. A method according to claim 3, further comprising the steps of

k) next, performing a computerized search of said new collection of informational words for a word which contains an exit of a non-routine logical part, from which a particular LDF starts, this word identifying an entrance of a non-routine logical part referred thereafter as a "following" part, which is linked to a starting part, then printing out a portion of this word, containing an address of the exit of the starting part, on one line, and printing out another portion of this word containing an address of the entrance of the linked "following" part on another line;

l) next, searching for an informational word, which contains an exit of the "following" part, belonging to said particular LDF, then printing out a portion of this word, containing an address of the exit of the "following" part, on one line, and printing out another portion of this word, containing an address of an entrance of a next linked "following" part, on another line;

m) repeating this search until a last logical part, at which LDF stops, is reached, whereby a linear data flow containing all related non-routine parts is printed out.

5. A method according to claim 3, further comprising the steps of

k) next, performing a computerized search of said collection of informational words for words, which contain all exits of a non-routine logical part wherefrom a particular LDF starts, then printing out these words in a consecutive order of exit numbers, provided that a word with an exit, which belongs to said particular LDF, is being printed last, this word identifying an entrance of a non-routine logical part (referred thereafter as a "following" part) which is linked to a starting part, and which belongs to said particular LDF, a portion of this word, containing an address of the exit, being printed on one line, and a portion of the word, containing an address of the entrance of the "following" part, being printed on another line;

l) next, searching for informational words, which contain all exits of the "following" part, and printing out these informational words in a consecutive order of exit numbers, provided that a word with an exit, which belongs to said particular LDF, is being printed the last so that a portion of this word, containing an address of the exit, is being printed on one line, and another portion of this word, containing an address of an entrance of a next "following" non-routine part, is being printed on another line;

m) repeating this search until a last logical part, at which LDF stops, is reached, whereby a linear data flow containing all related non-routine parts and subroutine parts is printed out in a textual form.

Description

FIELD OF THE INVENTION

The invention relates to perfective maintenance of long-lived computer programs, and more specifically, to data processing methodology and apparatus for effecting an improved numerical description of a logical structure of a large computer program.

BACKGROUND OF THE INVENTION

There exist huge unstructured or badly structured programs, which have been modified over many years and which continue to need maintenance. In many cases long-lived programs are represented by only a running code, with no other reliable external documentation. In order to make these programs (a) easier to read, and (b) easier to analyze impact of changes on a program, it was proposed in our U.S. Pat. No. 4,833,641 to reverse-engineer numerical documentation from a source code without changing a single line of the code. In the first stage of reverse engineering, the program is dissected into formal logical parts. Each part starts with a line to which control over data-processing is transferred from any other logical part in the program, said part ending at a line preceding the entrance of a subsequent logical part, or at a RETURN command if the logical part is a routine. In the second stage of reverse engineering each transfer of control is described by two addresses: (1) an address of an exit of one logical part, and (2) an address of an entrance of a linked logical part. The entrance address is defined by at least three attributes: 1) by an entrance number, which is always 0 (zero), because each part has one and only one entrance, 2) by a part number, and 3) by a label (number) of entrance line. The exit address can be defined only by an exit number and by a part number. A label (number) of exit line is optional if all exits are consecutively numbered from 1 and up starting with the closest exit to a part entrance. Routine logical parts were suggested to number from 500 and up, and non-routine logical parts--from 100 up to 499. This description of a link by at least five attributes is complemented in the third stage of reverse engineering by a semantic description of functioning of each part with the help of part's names. A process of naming transforms a formal logical part into a functional part with or without changing the formal part. In some cases several formal parts, which perform the same function, are integrated into one functional part. In other cases one formal part may be dissected into several functional parts, each of them performing an individual function. Though dissecting a program into formal logical parts can be done by a computer with no human involvement, declaration of functional names requires involvement of a person who is familiar with the program. If a program is written in COBOL language, or if a program is amply supplied with remark statements, then functional parts may be declared without human involvement. A combination of numerical and semantic description of two linked parts creates an informational word. In a collection of informational words each word is consecutively numbered. This collection of informational words (also called a "genetic collection" of links) is used in the forth stage of reverse engineering for creating an immediate environment of each functional part. All links of the genetic collection are searched for those words, which contain a particular part, then these words are printed out being arranged in a consecutive order of entrance/exit numbers. A source code can now be substituted by numbered portions of the code identified as functional logical parts, each part being located on a separate page and complemented by a description with the help of informational words of an immediate environment of this part. A collection of these parts arranged in a consecutive order of part numbers belongs to documentation "in-the-small", called as such because it is directly tied up with the source code. A list of entrances of all functional parts arranged in a consecutive order of entrance labels also belongs to documentation "in-the-small", as well as a genetic collection of links.

Documentation "in-the-small" is powerful enough for conducting corrective program maintenance, which we define as one that either causes no alterations in a program logic, or these alterations are not significant. A change in any logical part can easily be documented supplying all comments about this particular change on a page, where the part is located. Impact of the change can readily be evaluated analyzing immediate environment of the changed part.

A process of creating documentation "in-the-small" can not be realized only by a human without computer involvement. A human has a limited ability to remember which does not commensurate with a huge amount of information that a human receives during his life-time. In order to protect memory from saturation Nature supplied a human with the ability to get tired and to forget. However, fatigue and forgetfulness cause human mistakes which would flood numerical documentation "in-the-small" if the documentation were created by a human without the help of a computer. Suppose we deal with a program, which has just 200 transfers of control, each one being described by an information word, which has 30 characters, or 6000 characters in total. If we conservatively assume 1% as a level of human erroneousness, we will arrive at 60 mistakes while a collection of all links is created, then another 60 multiplied by n mistakes while immediate environment for each logical part is created (where n shows how many times on average each informational word is repeated in all immediate environments). At a stage of creating documentation a human search for these mistakes is frustratingly ineffective--it is like looking for a needle in a hay stack. Computer memorizes a genetic collection of informational words only. All other collections, like the immediate environment of each part, are derived by a computerized search of this genetic collection. The derived collections make human mistakes conspicuous: for instance, an error in a part number of a particular exit address (say, part 101, exit 1 instead of correct--part 100, exit 1) will be found in the immediate environments of both parts (exit 1 of part 100 will be missing, whereas part 101 will be having two exits 1). After all mistakes conspicuously exhibited by a computer in the documentation "in-the-small" are corrected, the genetic collection will become error-free.

Documentation "in-the-small" is not effective for conducting perfective maintenance, which includes program enhancement or program reusing in order to meet new requirements of a user, and which ordinarily causes substantial alterations in a program logic. A global overview of a program by considering a succession of logical parts, rather than each individual part and its immediate environment, is needed in order to conduct this type of maintenance. These successions of functional parts create program circuits, which constitute documentation "in-the-large".

We address in this invention the problem of developing documentation "in-the-large" from documentation "in-the-small".

SUMMARY OF THE INVENTION

It is an object of this invention to provide a method and means for describing successions of functional parts, and particularly a succession of non-routine logical parts. A succession of parts is like a linear circuit in electrical schematics. A linear program circuit comprises all program statements, which a computer executes performing a certain task of data-processing, the name of this task being used as a name of the program circuit. On the other hand a program circuit is a succession of informational words, which describe links between parts following each other, and since the function of each part is semantically described by a part's name we arrive at a succession of names describing a data flow. A linear program circuit constitutes therefore a linear data flow (LDF), besides being a linear control flow (flow of links). A collection of program circuits belongs to documentation "in-the-large", which is indispensable for global analysis.

In order to formally declare linear program circuits a map of all functional non-routine parts should be drawn. The first linear circuit starts with the beginning logical part of a program. The first circuit is arbitrarily drawn without loops through the succession of logical parts (whether branching or non-branching) until this circuit reaches the end of the program. A linear circuit should have at least two links following each other, which include three logical parts. One link (two parts) does not create a circuit. The first circuit builds a stem of the program to be used for declaring the rest of program circuits. However complicated the first circuit may be, in fact, it will execute a certain mode of program operation.

The second circuit starts from the branching part, which is the closest to the program end. One branch of said part should belong to the first circuit. The second circuit should end at another branching part, or at the end of the program, or at a rooting part which already belongs to another linear circuit. When all branches of the branching part are exhausted for declaration of subsequent program circuits, the procedure of declaration is transferred to the next branching part, one branch of which belonging to the first program circuit. The process of declaring linear program circuits is over when there is no logical part left which belongs to at least one program circuit.

When all linear program circuits are formally declared (drawn and numbered) the process of naming these circuits starts, involving a person familiar with the program. Same as with the formal parts, naming formal circuits may require dissecting some circuits into separate ones, or vice versa-integrating several formal circuits into one program circuit with one name. After program circuits are named, their numbers are incorporated into informational words, creating a separate field for LDF number, or adding a circuit number to a part's name locating, say, a three-digit number (making it possible to have 999 LDFs) before the name of a part. Obviously only those informational words, which link two logical parts will contain the LDF number. If a link contains a subroutine, there is no LDF number present in this informational word, because any subroutine may be called many times from different logical parts, which belong to different program circuits.

The genetic matrix which contains numbers of program circuits can be used for automatic printout of a linear program circuit, providing the computer with the number and name of the LDF, and also with the numbers of logical parts from which the circuit starts and at which it ends. The computer will find the informational word containing the starting part, print it out, then find the word with a connecting link, which has the same LDF number, and print it out, and so on until the last part is reached.

There are at least two types of linear circuits which can be printed out with the help of a computer. One type of a circuit contains only logical parts and no subroutines. This type of program circuit is helpful for simulating program functioning so far as this functioning is correctly reflected in a genetic collection of links. In case there are no errors present in informational words, which belong to a particular LDF, a complete program circuit will be printed out, otherwise the printout of the circuit will stop before a last part was reached. Apparently, a circuit composed of non-routine logical parts only, can not be used as a description of a data flow, because the names of functions, which routines perform, are missing.

The second type of program circuits contains routines as well as non-routine logical parts. This type of circuits can, in fact, describe a data flow since a circuit printout contains semantic description of all portions of a program involved in executing a particular data-processing task which a given program circuit performs.

Providing an overview of program functioning is not the only advantage of linear program circuits. Another advantage of program circuits is to provide means for simulating program functioning without actually running a program, as it was mentioned above.

Program circuits are also helpful in analyzing a control flow.

Program circuits are advantageous for recording structural changes and pertaining remarks describing causes of changes.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and additional features and advantages of this invention will become more easily understood from the following description of illustrative embodiment thereof taken into conjunction with the accompanying drawings in which:

FIG. 1 is a schematic block diagram which represents the invented method and the machine for describing logical structure of a computer program.

FIG. 2A and FIG. 2B are portions of a schematic flow chart of a program which controls functioning of a processing unit according to methodology of the present invention.

FIG. 3 is a control flow diagram created from the immediate environments of non-routine logical parts.

FIG. 4 is a schematic flow chart of a program, which controls processing unit during the LDF printout option.

DESCRIPTION OF THE PREFERRED EMBODIMENTS

Referring now to FIG. 1, there is shown an illustration of one of this principles of the invention. A parent collection of informational words (10) numerically describing links within a computer program, said collection being stored on a magnetic tape and also on other available informational storage means, is entered into processing unit (12) with the help of one of input devices (11). An input device may be a tape recorder, or a disk drive, or other information storage means. Functioning of processing unit (12) is controlled by a program, a flow chart of which is shown in FIG. 2A.

Beginning at top of FIG. 2A the program starts with declaring in functional block 50 the dimensions of variables used in the program. Variables are then initialized in the next functional block 51, after which control over data processing is transferred to decision block 52, which inquires whether a parent file exists. A "NO" output brings to functional block 53, where a file starts and then is saved on a magnetic storage device in functional block 54, arriving subsequently at a program menu (functional block 55).

A "YES" output of a "HAVE FILE ?" decision block 52 transfers control to functional block 56, which inquires information about the parent file, said file containing collection of informational words. The parent file is read in functional block 57.

A parent collection of informational words may be like the following one, which represents the first 7 lines of said collection:

    ______________________________________
    950     100    1           50   101  0
    70      101    1           250  102  0
    275     102    1           1000 103  0
    1005    103    1           1100 104  0
    1010    103    2           1200 105  0
    1015    103    3           1300 106  0
    1020    103    4           1400 107  0
    ______________________________________

    __________________________________________________________________________
    950
       100 1  DIMENS   50  101
                              0  INITIAL
    70 101 1  INITIAL  250 102
                              0  MODE MENU
    275
       102 1  MODE MENU
                       1000
                           103
                              0  SELECTOR
    1005
       103 1  SELECTOR 1100
                           104
                              0  UPDATING
    1010
       103 2  SELECTOR 1200
                           105
                              0  LISTING
    1015
       103 3  SELECTOR 1300
                           106
                              0  COPYING
    1020
       103 4  SELECTOR 1400
                           107
                              0  STARTING
    __________________________________________________________________________

    ______________________________________
    1115 104    1     UPDATING 1500 500  0   PARENT INF
    ______________________________________

    __________________________________________________________________________
    DOCUMENT 1
    Program
         Unit/
             Exit/      Program
                             Unit/
                                 Exit/       Memory
    line SUB Entr
                Name    line Sub Entr
                                    Name     #
    __________________________________________________________________________
    950  100 1  DIMENS  50   101 0  INITIAL  1
    70   101 1  INITIAL 250  102 0  MODE MENU
                                             2
    275  102 1  MODE MENU
                        1000 103 0  SELECTOR 3
    1005 103 1  SELECTOR
                        1100 104 0  UPDATING 4
    1010 103 2  SELECTOR
                        1200 105 0  LISTING  5
    1015 103 3  SELECTOR
                        1300 106 0  COPYING  6
    1020 103 4  SELECTOR
                        1400 107 0  STARTING 7
    900  100 0  DIMENS  5    115 1  RUN      8
    1115 104 1  UPDATING
                        1500 500 0  PARENT INF
                                             9
    1120 104 2  UPDATING
                        9110 550 0  PRINT INF
                                             10
    1130 104 3  UPDATING
                        3000 501 0  READ PARENT
                                             11
    1140 104 4  UPDATING
                        1600 108 0  DAUGTR FILE
                                             12
    __________________________________________________________________________

    __________________________________________________________________________
    DOCUMENT 2
    Program
         Unit/
             Exit/      Program
                             Unit/
                                 Exit/         Memory
    line SUB Entr
                Name    line Sub Entr
                                    Name       #
    __________________________________________________________________________
    900  100 0  DIMENS  5    115 1  RUN        8
    950  100 7  DIMENS  50   101 0  INITIAL    1
    50   101 0  INITIAL 950  100 1  DIMENS     1
    70   101 1  INITIAL 250  102 0  MODE MENU  2
    250  102 0  MODE MENU
                        70   101 1  INITIAL    2
    275  102 1  MODE MENU
                        1000 103 0  SELECTOR   3
    1000 103 0  SELECTOR
                        275  102 1  MODE MENU  3
    1005 103 1  SELECTOR
                        1100 104 0  UPDATING   4
    1010 103 2  SELECTOR
                        1200 105 0  LISTING    5
    1015 103 3  SELECTOR
                        1300 106 0  COPYING    6
    1020 103 4  SELECTOR
                        1400 107 0  STARTING   7
    1100 104 0  UPDATING
                        1005 103 1  SELECTOR   4
    1115 104 1  UPDATING
                        1500 500 0  PARENT INF 9
    1120 104 2  UPDATING
                        9110 550 0  PRINT INF  10
    1130 104 3  UPDATING
                        3000 501 0  READ PRNT FILE
                                               11
    1140 104 4  UPDATING
                        1600 108 0  DAUGHTER FILE
                                               12
    __________________________________________________________________________

    __________________________________________________________________________
    DOCUMENT 3
    Program
         Unit/
             Exit/         Program
                                Unit/
                                    Exit/       Memory
    line SUB Entr
                Name       line Sub Entr
                                       Name     #
    __________________________________________________________________________
    1500 500 0  PARENT INF 1115 104 1  UPDATING 9
    3000 501 0  READ PRNT FILE
                           1130 104 3  UPDATING 11
    3000 501 0  READ PRNT FILE
                           95   136 3  CREATE REF
                                                266
    3000 501 0  READ PRNT FILE
                           2715 528 4  READ LISTING
                                                415
    __________________________________________________________________________

    __________________________________________________________________________
    DOCUMENT 4
    Program
         Unit/
             Exit/         Program
                                Unit/
                                    Exit/      Memory
    line SUB Entr
                Name       line Sub Entr
                                       Name    #
    __________________________________________________________________________
    50   101 0  INITIAL    1600 100 1  DIMENS  1
    250  102 0  MODE MENU  70   101 1  INITIAL 2
    900  100 0  DIMENS     5    115 1  RUN     8
    1000 103 0  SELECTOR   275  102 1  MODE MENU
                                               3
    1100 104 0  UPDATING   1005 103 1  SELECTOR
                                               4
    1200 105 0  LISTING    1010 103 2  SELECTOR
                                               5
    1300 106 0  COPYING    1015 103 3  SELECTOR
                                               6
    1400 107 0  STARTING   1020 103 4  SELECTOR
                                               7
    1500 500 0  PARENT INF 1115 104 1  UPDATING
                                               9
    1600 108 0  DAUGHTER FILE
                           1140 104 4  UPDATING
                                               12
    __________________________________________________________________________

    __________________________________________________________________________
    Program
         Unit/
             Exit/     Program
                            Unit/
                                Exit/      Memory
    line SUB Entr
                Name   line Sub Entr
                                   Name    #
    __________________________________________________________________________
    1000 103 0  SELECTOR
                       275  102 1  MODE MENU
                                           3
    1005 103 1  SELECTOR
                       1100 104 0  UPDATING
                                           4
    1010 103 2  SELECTOR
                       1200 105 0  LISTING 5
    1015 103 3  SELECTOR
                       1300 106 0  COPYING 6
    1020 103 4  SELECTOR
                       1400 107 0  STARTING
                                           7
                 1000
                    REM *** 103 SELECTOR ***
                 1005
                    IF K = 1 GOTO 1100
                 1010
                    IF K = 2 GOTO 1200
                 1015
                    IF K = 3 GOTO 1300
                 1020
                    IF K = 4 GOTO 1400
    __________________________________________________________________________

    ______________________________________
    PROGRAM           PROGRAM AMENDMENT
    ______________________________________
    1000 REM *** 103 SELECTOR ***
    1005 IF K = 1 GOTO 1100
    1010 IF K = 2 GOTO 1200
    1015 IF K = 3 GOTO 1300
    1020 IF K = 4 GOTO 1400
               enter: 1017 IF K = 5 GOTO 2620
    ______________________________________

    ______________________________________
    1017  103    4      2620 125   0   JOURNAL SEARCH.
    ______________________________________

    __________________________________________________________________________
    ACTION
          MEM #
               UNIT/SUB
                      DESCRIPTION OF AMENDMENT
                                         REMARK
    __________________________________________________________________________
    CREATE     125    1017  103  4  SELECTOR
                      2620  125  0  JOURNAL SEARCH
    AMEND
    DELETE
    CREATE
          7    107    4.fwdarw.5
    AMEND
    DELETE
    __________________________________________________________________________

    __________________________________________________________________________
    DOCUMENT 1 with LDFs
    Program  Exit/        Program  Exit/         Memory
    line PART
             Entr
                Name      line PART
                                   Entr
                                      Name       #
    __________________________________________________________________________
    950  100 1  001 DIMENS
                          50   101 0  001 INITIAL
                                                 1
    70   101 1  001 INITIAL
                          250  102 0  001 MODE MENU
                                                 2
    275  102 1  001 MODE MENU
                          1000 103 0  001 SELECTOR
                                                 3
    1005 103 1  002 SELECTOR
                          1100 104 0  002 UPDATING
                                                 4
    1010 103 2  003 SELECTOR
                          1200 105 0  003 LISTING
                                                 5
    1015 103 3  004 SELECTOR
                          1300 106 0  004 COPYING
                                                 6
    1020 103 4  005 SELECTOR
                          1400 107 0  005 STARTING
                                                 7
    900  100 0  001 DIMENS
                          5    115 1  001 RUN    8
    1115 104 1  UPDATING  1500 500 0  PARENT INF 9
    1120 104 2  UPDATING  9110 550 0  PRINT INF  10
    1130 104 3  UPDATING  3000 501 0  READ PARENT
                                                 11
    1140 104 4  002 UPDATING
                          1600 108 0  002 DAUGTR FILE
                                                 12
    __________________________________________________________________________

    __________________________________________________________________________
    LDF 001                  STARTING part 115: LAST part 103
    Program  Exit/        Program  Exit/  Memory
    line PART
             Entr
                Name      line PART
                                   Entr
                                      Name
                                          #
    __________________________________________________________________________
    50   115 1  001 RUN
    900  100 0  001 DIMENS                8
    950  100 1  001 DIMENS
    50   101 0  001 INITIAL               1
    70   101 1  001 INITIAL
    250  102 0  001 MODE MENU             2
    275  102 1  001 MODE MENU
    1000 103 0  001 SELECTOR              3
    __________________________________________________________________________

    __________________________________________________________________________
    LDF 002                        STARTING part 103: LAST part 108
    Program  Exit/         Program  Exit/       Memory
    line PART
             Entr
                Name       line PART
                                    Entr
                                       Name     #
    __________________________________________________________________________
    1005 103 1  002 SELECTOR
    1100 104 0  002 UPDATING
    1115 104 1  UPDATING   1500 500 0  PARENT INF
                                                9
    1120 104 2  UPDATING   9110 530 0  PRINT INF
                                                10
    1130 104 3  UPDATING   3000 501 0  READ PARENT
                                                11
    1140 104 4  002 UPDATING
    1600 108 0  002 DAUGTR FILE                 12
    __________________________________________________________________________

• Inventors
  Lerner, Moisey;
• Published
  Oct-20-1992
• Current US Classes:
  717/107
• Application #
  217359
• International Classes
  G06F 007/00; G06F 007/10; G06F 007/12; G06F 007/38
• Field of Search
  364/200
• Examiner
  Williams, Jr.; Archie E.
• Agent
  Tomin Corporation
• US Patent References:
  4387427
  4468736
  4595981
  4642767
  4683549
  4730315
  4833641
  4872167