System and method of encoding units of data including entity/relationship data, function calls and file data using a common format (CDF) according to formal CDF grammar rules

Abstract

Method and means are described for encoding and decoding stored units of data representing entity/relationship (E/R) data, function calls, and file data by including a prefix with each unit of data which includes a length code, an action code, and a unit identifier code. The data units with prefixes are organized into a data stream by using rules described in a formal grammar. The data stream will typically be transmitted to another program inside the computer or to another computer host or programmable workstation (PWC). When received the data stream is parsed back into data units by reversing the encoding process. After the data units are recovered the appropriate action is taken to process the units. E/R data is entered into or updated in a repository, function calls are passed on to an E/R repository function or other program along with the specified parameters for execution, and file data is stored in standard files. Generated output is captured, encoded into a data stream and transmitted back to requesting PWS which then parses the data stream to recover the output data.

Claims

What is claimed is:

1. A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform method steps for encoding units of data, the machine having stored units of data, said method steps comprising:

(1) reading units of data from storage, each unit of data representing one of entity/relationship data, a function call, and file data; and

(2) encoding all of said units of data using a common data format (CDF) according to formal CDF grammar rules to create a data stream comprising said encoded units of data.

2. The program storage device of claim 1, wherein the machine is linked to a remote computer, said method steps further comprising the step of transmitting the data stream to the remote computer.

3. The program storage device of claim 1, wherein step (2) comprises the steps of:

(a) selecting one of said units of data;

(b) generating a prefix for said selected unit of data; and

(c) appending said prefix and said selected unit of data to said data stream; and

(d) performing steps (a)-(c) for each of said units of data;

wherein step (b) comprises the steps of:

(i) encoding a length of said prefix and said selected unit of data into a length field of said prefix;

(ii) encoding an action associated with said selected unit of data into an action field of said prefix; and

(iii) encoding an identifier of said selected unit of data into an identifier field of said prefix.

4. A program storage device readable by a remote computer, tangibly embodying a program of instructions executable by the remote computer to perform method steps for processing units of data in a data stream generated by a local computer, the units of data in the data stream each representing one of entity/relationship data, a function call, and file data, the local computer having encoded all of the units of data using a common data format (CDF) according to formal CDF grammar rules to create the data stream, said method steps comprising the steps of:

(1) parsing the data stream according to said formal CDF grammar rules to extract the units of data from the data stream;

(2) detecting a function call in one of said extracted units of data; and

(3) passing the function call to a function processor for processing.

5. The program storage device of claim 4, wherein said method steps further comprise the steps of:

(4) collecting one or more units of output data generated by execution of the function call;

(5) encoding said one or more units of output data using said common data format (CDF) according to said format CDF grammar rules to create a second data stream comprising said encoded units of output data; and

(6) transmitting said second data stream to the local computer system.

6. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a processor in a computer system to encode units of data, the computer system having stored units of data, said computer program product comprising:

means for enabling the processor to read units of data from storage, each unit of data representing one of entity/relationship data, a function call, and file data; and

means for enabling the processor to encode all of said units of data using a common data format (CDF) according to formal CDF grammar rules to create a data stream comprising said encoded units of data.

7. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a processor in a remote computer system to process units of data in a data stream generated by a local computer, the units of data in the data stream each representing one of entity/relationship data, a function call, and file data, the local computer having encoded all of the units of data using a common data format (CDF) according to formal CDF grammar rules to create the data stream, said computer program logic comprising:

means for enabling the processor to parse the data stream according to said formal CDF grammar rules to extract the units of data from the data stream;

means for enabling the processor to detect a function call in one of said extracted units of data; and

means for enabling the processor to pass the function call to a function processor for processing.

8. The computer program product of claim 7, wherein said computer program logic further comprises:

means for enabling the processor to collect one or more units of output data generated by execution of the function call;

means for enabling the processor to encode said one or more units of output data using said common data format (CDF) according to said formal CDF grammar rules to create a second data stream comprising said encoded units of output data; and

means for enabling the processor to transmit said second data stream to the local computer.

Description

FIELD OF THE INVENTION

The present invention relates to systems and methods for encoding, decoding, moving and manipulating computerized data and more particularly data relating to entities and relationships.

BACKGROUND OF THE INVENTION

As used in the field of this invention, entities and relationships are special forms of data that are intended to represent information that is useful in the process of designing and writing computer programs. When this information is stored in a retrievable manner it can be used to aid in the development of computer programs. There are various commercial software systems available which are specially designed to manipulate entity/relationship (E/R) data. One of these systems is IBM's Repository Manager (RM). RM is a predominantly host computer based program. Users of RM may enter their data manually using dialog panels or custom programs may be developed to create, update and retrieve the data. RM provides a set of callable functions which can be accessed by other programs. New RM functions can be created by users as well. These callable functions typically require one or more parameters to perform correctly. It is standard practice in the industry for users to have a personal computer or programmable workstation (PWS) which is used to interface with host computer based programs. When the PWS is sharing the workload with the host, the system is said to be "cooperative". Many kinds of data, not only E/R data, are stored in files. These files may be located on either the host or the PWS.

There is a need for efficient ways to encode E/R data, function calls, and file data in a format which can be transmitted between a PWS and another computer.

Packaging data in a data format of self-describing units is known in the art. The use of grammars as a way of precisely defining syntax is also well known. An efficient comprehensive grammar for self-describing data stream of E/R related data which meets the described need is not found in the prior art.

SUMMARY OF THE INVENTION

The invention provides method and means for encoding and decoding stored units of data representing entity/relationship data, function calls, and file data by including a prefix with each unit of data which includes a length code, an action code, and a unit identifier code. The data units with prefixes are built into a data stream by using rules described in a formal grammar. The data stream can be stored in temporary or permanent storage in the computer. It may be transmitted to another program on the same computer or to another computer--host or PWS. When received the data stream is parsed back into data units by reversing the encoding process. After the data units are recovered the appropriate action may be taken to process the units. E/R data may be entered into or updated in a repository, function calls may be passed on to the appropriate functions along with the specified parameters for execution, and file data may be stored. Generated output data is captured, encoded and returned to the requesting system as a data stream which must be parsed.

DESCRIPTION OF THE DRAWINGS

FIG. 1 shows the block structure of a PWS and host using the invention.

FIG. 2 shows the overview of the steps involved in executing a function call using the invention.

FIG. 3 shows an overview of the build process of the invention.

FIG. 4 shows a representation of a Template Tree Instance used as an example.

DETAILED DESCRIPTION OF THE INVENTION

The invention is embodied in a larger system which will be called the Entity/Relationship Data Movement and Manipulation tool (EDMM) which is designed for use with IBM's Repository Manager/MVS. The invention is, however, independent of the particular host tool used as the repository for the E/R data. EDMM has five components. The first four components described are run-time facilities; the fifth, PF, is used during development, Each of these components is described in detail in later sections. They are:

1. Common Data Format (CDF): EDMM's common data interchange format, which is a means of consistently representing E/R, file record data and function call information within a data stream.

2. Builder: The function that creates a CDF data stream from E/R, file record and function call data.

3. Parser: The function that interprets and decodes information in a CDF data stream.

4. Communication Facility (CF): The function which provides data transfer and remote function routing between work station and host platforms.

5. Productivity Facility (PF): The facility for creating Repository Manager data handling functions based on the work station tool's view of the E/R data.

The overall structure of a host connected PWS system using the invention is shown in FIG. 1. The invention can be used in any system requiring transmission or storage of E/R related data. Thus, a PWS to PWS or host to host connection will work, as will any combination of networked computers. The operation of the system is controlled by a user supplied Application Program 26 which supplies the data and commands for the components of EDMM. The components of the invention are an EDMM Builder, Parser, and Communication Facility. The PWS Builder 11 is required to encode the raw units of data into a formatted data stream. The PWS Parser 15 decodes a formatted data stream. The PWS Communication Facility (CF) 13 provides the high level interface to a standard computer-to-computer communication means 17. Most Builder 12, Host Parser 16, and Host Communication Function 14 provide similar function on the host side, but the internals may be different because the host computer may have an instruction set or operating system that is different than that of the PWS. The Host Communication Function also includes a Router 22, which provides means to detect the presence of and appropriately route the E/R data, function calls, and file data in the data stream. The Function means 20 may be a part of EDMM, may be supplied as a part of a system such as the Repository Manager and/or may include functions supplied by the operating system. E/R data from the PWS is routed to Load means 19. The Unload means 21 is used to retrieve E/R data from the repository and return it to the PWS. The E/R data is stored in the repository means 18 such as is provided through IBM's Repository Manager/MVS. File data is stored in whatever standard way is provided by the operating system such as an MVS partitioned data set (PDS) 23. The Load, Unload, and other Functions may generate output which is captured and routed back to the PWS through the link.

A CDF data stream consists of units of binary and character data. Each unit contains a self-describing prefix area followed by a variable-length data area that might contain other nested units. The prefix area containers a 4-byte length field, a 1-byte action field, and a 1-byte unit identifier field. The data area may or may not contain data depending upon the type of unit being described.

The CDF data stream is supported by two functions, the Parser and the Builder, which exist on both the work station and the host. These functions provide users with an external view of a CDF data stream by dealing with the complexities of the CDF as well as ensuring the syntactical correctness of the data stream. Any function that deals with a CDF data stream must go through the Builder and Parser. The purpose of the Builder is to build a CDF data stream one unit at a time. The purpose of the Parser function is to retrieve data one unit at a time from a CDF data stream. It allows the user to interpret data in the CDF.

The Communication Facility is the component of the EDMM Tool that allows the communication of remote function calls and other information between work station tools and host-based Repository Manager functions. This component relies on RM/PWS, which is supplied with the Repository Manager, to communicate between the host and the work station. A tool on the work station invokes the CF function on the workstation, passing it a CDF data stream containing function call information and any other data necessary to invoke that function. The Host CF interprets the CDF data stream and routes the function calls to the appropriate host Repository Manager function. After the Repository Manager function(s) have executed, the output parameters and processing results are returned to the work station tool in another CDF data stream.

The Productivity Facility (PF) is the component that enables the rapid creation of data manipulation functions based on a variety of views of E/R data in the repository. The PF creates Repository Manager data handling C-Language functions, as described below, for any configuration of entities and relationships defined by the user.

Unload:

A function that retrieves a group of connected entities and relationships from the repository and translates the entity, attribute, and relationship information via the Builder function into a CDF data stream.

Load:

A function that interprets a CDF data stream containing entity, attribute, and relationship information, updating the repository as specified by the action field of each CDF unit.

Delete:

A function that deletes a group of connected entity and relationship instances from the repository.

Copy:

A function that copies a group of connected entity and relationship instances in the repository.

To create an Repository Manager function using PF, the tool builder must first fully define the function to Repository Manager, and generate the Repository Manager function report. The generated Repository Manager report is input to the Productivity Facility, which produces the desired Repository Manager C-Language function based on the tool builder's view of the E/R data. A fully defined Repository Manager function includes the definition of templates and connections.

EDMM RUN-TIME SCENARIO

FIG. 2 will be used to illustrate the overall process of how a work station application and the host interact when the arbitrary function, which will be called FUNCTION.sub.-- X, on the host is called from the work station. This scenario can easily be generalized for any activity requested by the application on the workstation.

The scenario is as follows:

1. The application on the workstation uses the Builder function to build a CDF data stream, specifying the FUNCTION.sub.-- X function to be invoked on the host along with FUNCTION.sub.-- X's input parameter values 31. The data stream may be stored temporarily (in RAM) or more permanently on disk or tape.

2. The application on the work station transmits the data stream to the host by invoking CF on the work station using a regular C function call, passing a pointer to the CDF data stream as input 32. If the host uses a character set which is different from the PWS, then a character set translation is performed by the PWS CF before the data is transmitted.

3. The CF function on the workstation transfer the CDF data to the CF counterpart on the host.

4. After parsing the data stream, 33, the routing is performed 34 based on the FUNCTION.sub.-- X function call information in the CDF data stream, the CF router function on the host sets up the appropriate FUNCTION.sub.-- X parameter template with input parameter values from the data stream and invokes the FUNCTION.sub.-- X host Repository Manager function.

5. The FUNCTION.sub.-- X function processes.

6. Upon completion, the FUNCTION.sub.-- X function sets the output parameter values and returns to the host CF function with its output parameters in the FUNCTION.sub.-- X Repository Manager parameter template 35. Some functions might only generate a return code, but the return code will be processed through the builder the same as other types of data.

7. The CF function on the host takes output parameters from FUNCTION.sub.-- X's parameter template and, using the Builder function 36, plates them back into the CDF data stream to be returned to the CF function on the workstation.

8. The CF function on the host returns the CDF data stream to its counterpart CF function on the work station. If character set translation is required, it is performed by the CF after the data is transmitted back to the PWS. The CF function on the work station returns The CDF data to the application 37.

9. The application uses the Parser function 38 to obtain results of the host function call from the CDF data stream, displaying the results to the user where necessary via dialogs, pop-up windows, etc.

Function calls can include E/R data or file data as input or out parameters. The process of handling E/R data coming from the PWS is also similar, but in this case the routing will invoke the Load means which places the E/R data into the repository. Requesting the Unload function results in outputting E/R data that is encoded and sent back to the PWS.

In FIG. 3 an overview of the build process is shown. When the first unit is processed 41 the initialization of memory, etc. is performed 42. If the last unit has been processed 43, then the data stream is constructed from the unit data which has been previously stored in tree form in memory 44. Since the requests from the application program must be a correct sequence, the sequence must be validated 45. The builder and parser are both driven using finite state automata techniques. The state table will be described in detail in Table 1 later. Since only certain state transitions are valid, these are also checked 46. The data for the unit is then stored in a tree in memory for later use in building the final data stream 47.

The parsing process is the reverse of the build process. The application program passes the parser a pointer to a data stream in memory or gives a file name which contains the data stream. The parser returns one unit at a time back to the application program. The parser keeps its own internal pointer into the data stream. The state table of Table 1 describes the details of the state transitions.

FIG. 4 shows a representation of a Template Tree Instance which will be used as an example The data stream built from this Instance is 222 bytes long. The hexadecimal representation of this data stream is as follows:

    __________________________________________________________________________
    000000DE
          00020000
                002F0403
                      D7C5D9E2
                            D6D54040
                                  0000000C
                                        0005F1F2
                                              F4F4F5F6
    00000015
          0406D5C1
                D4C54040
                      4040D4C9
                            C3C8C1C5
                                  D3000000
                                        150403D4
                                              D6C4E4D3
    C5404000
          00000700
                05C10000
                      003F0407
                            F0F0F0F0
                                  F0F0F0F0
                                        F0F10000
                                              001A0009
    D7C5D9E2
          D6D54040
                0000000C
                      0005F1F2
                            F4F4F5F6
                                  00000015
                                        0009D4D6
                                              C4E4D3C5
    40400000
          00070005
                C1000000
                      180403C9
                            D5E36DD7
                                  D9D6C300
                                        00000A00
                                              05D7E4E2
    C8000000
          3D0407F0
                F0F0F0F0
                      F0F0F0F0
                            F2000000
                                  150009D4
                                        D6C4E4D3
                                              C5404000
    00000700
          05C10000
                00180009
                      C9D5E36D
                            D7D0D6C3
                                  0000000A
                                        0005D7E4
                                              E2C80000
    00000000
          00000000
                00000000
                      00000000
                            00000000
                                  00000000
    __________________________________________________________________________

    __________________________________________________________________________
    000000DE 0002
    Length = 222, action = 0(NONE), id = 2(E/R.sub.-- DATA.sub.-- GROUP.sub.--
     H)). data = none.
    0000002F 0403D7C5D9E2 D6D54040
    Length = 47, action = 4(READ), id = zz (TMPL.sub.-- ID), data = PERSON
    0000000C 0005F1F2 F4F4F5F6
    Length = 12, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    124456
    00000015 0406D5C1 D4C54040 4040D4C9 C3C8C1C5 D3
    Length = 21, action = 4(READ), id = 6(FIELD.sub.-- ID), data = NAME
    MICHAEL
    00000015 0403D4D6 C4E4D3C5 4040
    Length = 21, action = 4(READ), id = 3(TMPL.sub.-- ID), data = MODULE
    00000007 0005C1
    Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    0000003F 0407F0F0 F0F0F0F0 F0F0F0F1
    Length = 63, action = 4(READ), id = 7(REL.sub.-- ID). data = 0000000001
    0000001A 0009D7C5 D9E2D6D5 4040
    Length = 26, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID), data
    = PERSON
    0000000C 0005F1F2 F4F4F5F6
    Length = 12, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    124456
    00000015 0009D4D6 C4E4D3C5 4040
    Length = 21, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data
    = MODULE
    00000007 0005C1
    Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    A
    00000018 0403C9D5 E36DD7D9 D6C3
    Length = 24, action = 4(READ), id = 3(TMPL.sub.-- ID). data = INT PROC
    0000000A 0005D7E4 E2C8
    Length = 10, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    PUSH
    0000003D 0407F0F0 F0F0F0F0 F0F0F0F2
    Length = 61, action = 4(READ), id = 7(REL.sub.-- ID), data = 0000000002
    00000015 0009D4D6 C4E4D3C5 4040
    Length = 21, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data
    = MODULE
    00000007 0005C1
    Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    A
    00000018 0009C9D5 E36DD7D9 D6C3
    Length = 24, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data
    = INT.sub.-- PROC
    0000000A 0005D7E4 E2C8
    Length = 10, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =
    PUSH
    __________________________________________________________________________

    ______________________________________
    E/R.sub.-- DATA.sub.-- GROUP.sub.-- ID
                     NONE
    TMPL.sub.-- ID   READ     PERSON
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     124456
    FIELD.sub.-- ID  READ     NAME MICHAEL
    TMPL.sub.-- ID   READ     MODULE
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     A
    REL.sub.-- ID    READ     0000000001
    RELENT.sub.-- KEY.sub.-- ID
                     NONE     PERSON
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     124456
    RELENT.sub.-- KEY.sub.-- ID
                     NONE     MODULE
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     A
    TMPL.sub.-- ID   READ     INT.sub.-- PROC
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     PUSH
    REL.sub.-- ID    READ     0000000002
    RELENT.sub.-- KEY.sub.-- ID
                     NONE     MODULE
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     A
    RELENT.sub.-- KEY.sub.-- ID
                     NONE     INT.sub.-- PROC
    TMPL.sub.-- KEY.sub.-- ID
                     NONE     PUSH
    ______________________________________

    __________________________________________________________________________
    Non-terminals
    <cdf.sub.-- data.sub.-- stream>
                ::= <edmm.sub.-- data.sub.-- stream> .vertline. <er.sub.--
                data.sub.-- group> .vertline. <file.sub.-- data.sub.--
                group>
    <edmm.sub.-- data.sub.-- stream>
                ::= length <no.sub.-- action> edmm.sub.-- data.sub.--
                stream.sub.-- id <edmm .sub.-- data.sub.-- list>
    <edmm.sub.-- data.sub.-- list>
                ::= <edmm.sub.-- data> <edmm.sub.-- data.sub.-- list>
                .vertline. <edmm.sub.-- data>
    <edmm.sub.-- data>
                ::= <function.sub.-- call> .vertline. <function.sub.-- call>
                <er.sub.-- data.sub.-- group> .vertline.
                <function.sub.-- call> <file.sub.-- data.sub.-- group>
    <function.sub.-- call>
                ::= length <no.sub.-- action> fun.sub.-- call.sub.-- id
                fun.sub.-- name <fun.sub.-- parm.sub.-- list>
    <fun.sub.-- parm.sub.-- list>
                ::= <fun.sub.-- parm> <fun.sub.-- parm.sub.-- list> .vertline.
                 <HULL>
    <fun.sub.-- parm>
                ::= length <no.sub.-- action> fun.sub.-- parm.sub.-- id
                fun.sub.-- parm.sub.-- name
                fun.sub.-- parm.sub.-- value
    <er.sub.-- data.sub.-- group>
                ::= length <no.sub.-- action> er.sub.-- data.sub.-- group.sub.
                -- id <er.sub.-- data.sub.-- list>
    <er.sub.-- data.sub.-- list>
                ::= <er.sub.-- data> <er.sub.-- data.sub.-- list> .vertline.
                <er.sub.-- data>
    <er.sub.-- data>
                ::= <template> .vertline. <rel>
    <template>  ::= length <crud.sub.-- action> tmpl.sub.-- id
                template.sub.-- name
                <tmpl.sub.-- key.sub.-- list> <field.sub.-- list>
    <tmpl.sub.-- key.sub.-- list>
                ::= <tmpl.sub.-- key> <tmpl.sub.-- key.sub.-- list> .vertline.
                 <tmpl.sub.-- key>
    <tmpl.sub.-- key>
                ::= length <no.sub.-- action> temp.sub.-- tmpl.sub.--
                key.sub.-- id <temp.sub.-- key> .vertline.
                length <no.sub.-- action> tmpl.sub.-- key.sub.-- id
                key.sub.-- value
    <field.sub.-- list>
                ::= <field> <field.sub.-- list> .vertline. <NULL>
    <field>     ::= length <crud.sub.-- action> field.sub.-- id field.sub.--
                name field.sub.-- value
    <rel>       ::= length <crd.sub.-- action> rel.sub.-- id <rel.sub.-- key>
                <source.sub.-- key>
                <target.sub.-- key> .vertline.
                length <cu.sub.-- action> orel.sub.-- id <rel.sub.-- key>
                <rel.sub.-- posn>
                <source.sub.-- key> <target.sub.-- key>
    <source.sub.-- key>
                ::= <relent.sub.-- key> .vertline. <relrel.sub.-- key>
    <target.sub.-- key>
                ::= relent.sub.-- key> .vertline. <relrel.sub.-- key>
    <relent.sub.-- key>
                ::= length <no.sub.-- action> relent.sub.-- key.sub.-- id
                template.sub.-- name
                <tmpl.sub.-- key.sub.-- list>
    <relrel.sub.-- key>
                ::= length <no.sub.-- action> relrel.sub.-- key.sub.-- id
                rel.sub.-- key
    <file.sub.-- data.sub.-- group>
                ::= length <no.sub.-- action> file.sub.-- data.sub.--
                group.sub.-- id <file.sub.-- data.sub.-- list>
    <file.sub.-- data.sub.-- list>
                ::= <line> <file.sub.-- data.sub.-- list> .vertline. <line>
    <line>      ::= length <no.sub.-- action> line.sub.-- id line.sub.--
                value
    <crud.sub.-- action>
                ::= create .vertline. read .vertline. update .vertline.
                delete
    <cu.sub.-- action>
                ::= create .vertline. update
    <crd.sub.-- action>
                ::= create .vertline. read .vertline. delete
    <c.sub.-- action>
                ::= create
    <no.sub.-- action>
                ::= none
    <temp.sub.-- key>
                ::= unique.sub.-- key
    <rel.sub.-- key>
                ::= unique.sub.-- key
    <rel.sub.-- posn>
                ::= unique.sub.-- key .vertline. 0
    <NULL>      ::=
    Terminals
    length      ::= Binary(4) - Length of unit (including the prefix (
                length(4), action(1), and unit id (1)) plus data)
    none        ::= Binary(1) 00
    create      ::= Binary(1) 01
    delete      ::= Binary(1) 02
    update      ::= Binary(1) 03
    read        ::= Binary(1) 04
    edmm.sub.-- data.sub.-- stream.sub.-- id
                ::= Binary(1) 00
    fun.sub.-- call.sub.-- id
                ::= Binary(1) 01
    e/r.sub.-- data.sub.-- group.sub.-- id
                ::= Binary(1) 02
    tmpl.sub.-- id
                ::= Binary(1) 03
    temp.sub.-- tmpl.sub.-- key.sub.-- id
                ::= Binary(1) 04
    tmpl.sub.-- key.sub.-- id
                ::= Binary(1) 05
    field.sub.-- id
                ::= Binary(1) 06
    rel.sub.-- id
                ::= Binary(1) 07
    orel.sub.-- id
                ::= Binary(1) 08
    relent.sub.-- key.sub.-- id
                ::= Binary(1) 09
    relrel.sub.-- key.sub.-- id
                ::= Binary(1) 10
    fun.sub.-- parm.sub.-- id
                ::= Binary(1) 11
    file.sub.-- data.sub.-- group.sub.-- id
                ::= Binary(1) 13
    line.sub.-- id
                ::= Binary(1) 14
    template.sub.-- name
                ::= Char(8) - Name of entity template
    unique.sub.-- key
                ::= Char(10) - A temporary unique identifier for an entity
                whose key has not yet been generated by the repository, or
                a relationship instance. Allowable characters are 0-9,
                the associated integer value must be greater than zero.
    key.sub.-- value
                ::= Char(*) - Value of the key
    field.sub.-- name
                ::= Char(8) - Name of a template field
    field.sub.-- value
                ::= Char(*) - Value of the field
    fun.sub.-- name
                ::= Char(8) - Name of the function being invoked
    fun.sub.-- parm.sub.-- name
                ::= Char(8) - Name of a function parameter
    fun.sub.-- parm.sub.-- value
                ::= Char(*) - Value of a function parameter
    line.sub.-- value
                ::= Char(*) - Value of a line in a flat file
    __________________________________________________________________________

    ______________________________________
    int egppb100(
    unsigned short function.sub.-- id,
                   IN:      Function to perform
    short id,      IN:      Unit's id
    short action,  IN:      Unit's action
    UNIDATA *data, IN:      Unit's name, key, value
    char *filename,
                   IN:      File Name
    char **memptr, INOUT:   Ptr to block of memory
    B.sub.-- HNDL *handle,
                   INOUT:   Ptr to private data area
    char *cc)      OUT:     Reason code
    ______________________________________

    __________________________________________________________________________
    FIRST      Adds the first unit to the CDF Data Stream. This function is
               only issued once
               during the Building of a CDF data stream. The unit that
               accompanies the
               FIRST Build action only has an ID (i.e., there is no action
               and no associated
               data). Following is a list of the allowable units with which
               the FIRST function
               may be associated:
               EDMM Data Stream Adds an EDMM Data Stream unit to the Common
               Data
                          Format Data Stream
                          id   EDMM.sub.-- DATA.sub.-- STREAM.sub.-- ID
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               ER Data Group
                          Adds an ER.sub.-- Data Group unit to the Common
                          Data Format
                          Data Stream
                          id   ER.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               File Data Group
                          Adds a File Data Group unit to the Common Data
                          Format
                          Data Stream
                          id   file.sub.-- data.sub.-- group
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
    NEXT       Adds an additional unit. This unit contains an id, action, and
               data portion. If
               the Unit is a nesting unit, there may or may not be a data
               portion. Following is
               a list of the allowable units with which the Build's NEXT
               function may be
               associated:
               Function Call
                          Adds a function call unit to the Common Data Format
                          Data
                          Stream
                          id   FUN.sub.-- CALL.sub.-- ID
                          action
                               NONE
                          data
                                 name = fun.sub.-- name
                                 value = NULL (ignored)
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               Function Parm
                          Adds a function parameter unit to the Common Data
                          Format Data Stream
                          id   FUN.sub.-- PARM.sub.-- ID
                          action
                               NONE
                          data
                                 name = fun.sub.-- parm.sub.-- name
                                 value = fun.sub.-- parm.sub.-- value
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               ER Data Group
                          Adds an ER.sub.-- DATA.sub.-- group unit to the
                          Common Data Format
                          Data Stream
                          id   ER.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               Template   Adds a template unit to the Common Data Format
                          Data
                          Stream
                          id   TMPL.sub.-- ID
                          action
                                 CREATE
                                 READ
                                 UPDATE
                                 DELETE
                                 name = template.sub.-- name
                                 value = NULL (ignored)
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               Template Key
                          Adds a template key unit to the Common Data Format
                          Data Stream. There are two allowable variations.
                          id   TEMP.sub.-- TMPL.sub.-- KEY.sub.-- ID
                          action
                               NONE
                          data
                                 name = NULL (ignored)
                                 value = NULL (ignored)
                                 temp.sub.-- key = temp.sub.-- key
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
                          OR
                          id   TEMP.sub.-- KEY.sub.-- ID
                          action
                               NONE
                          data
                                 name = NULL (ignored)
                                 value = key.sub.-- value
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               Field      Adds a field unit to the Common Data Format Data
                          Stream
                          id   FIELD.sub.-- ID
                          action
                                 CREATE
                                 READ
                                 UPDATE
                                 DELETE
                          data
                                 name = field.sub.-- name
                                 value = field.sub.-- value
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          mempir
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               Rel        Adds a relationship unit to the Common Data Format
                          Data
                          Stream. There are two allowable variations.
                          id   REL.sub.-- ID
                          action
                                 CREATE
                                 READ
                                 DELETE
                          data
                                 name = NULL (ignored)
                                 value = NULL (ignored)
                                 temp.sub.-- key = rel.sub.-- key
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
                          OR
                          id   OREL.sub.-- H)
                          action
                                 CREATE
                                 UPDATE
                          action
                                 name = NULL (ignored)
                                 value = NULL (ignored)
                                 temp.sub.-- key = rel.sub.-- key
                                 rel.sub.-- posn = rel.sub.-- posn
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               relent key Adds a relationship's source target entity instance
                          key to the
                          Common Data Format Data Stream
                          id   RELENT.sub.-- KEY.sub.-- ID
                          action
                               NONE
                          data
                                 name = template.sub.-- name
                                 value = NULL (ignored)
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               relrel key Adds a relationship's source/target relationship
                          instance key
                          to the Common Data Format Data Stream
                          is   RELREL.sub.-- KEY.sub.-- ID
                          action
                               NONE
                          data
                                 name = NULL (ignored)
                                 value = NULL (ignored)
                                 temp.sub.-- key = rel.sub.-- key
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               file data group



                          Adds a file data group unit to the Common Data
                          Format
                          Data Stream
                          id   FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
               line       Adds a line unit to the Common Data Format Data
                          Stream.
                          id   LINE.sub.-- ID
                          action
                               NONE
                          data
                                 name = NULL (ignored)
                                 value = line.sub.-- value
                                 temp.sub.-- key = NULL (ignored)
                                 rel.sub.-- posn = NULL (ignored)
                          filename
                               NULL (ignored)
                          memptr
                               NULL (ignored)
                          handle
                               Handle to Builder's Control Block
    ADD.sub.-- STREAM
               Adds a complete, self-contained CDF data stream to the current
               data stream.
               The complete self contained data stream must have been built
               using the Builder.
               This unit contains the complete unit in a block of memory. The
               block of
               memory has all the lengths, and nested units resolved. No
               semantic checking will
               be performed on the units contained within this unit block.
               However, semantic
               checks will be performed to see if this unit is inserted in
               the current CDF data
               stream in the proper context.
                 The ADD.sub.-- STREAM action can be used with the following
               units. Note:
               Memptr and filename are mutually exclusive and required. One
               or the other must
               have a value, but not both.
               er data group
                          Adds a complete self-contained ER Data Group unit
                          to the
                          EDMM Data Stream
                          id   NO).sub.-- HO (ignored)
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL or filename of er.sub.-- data.sub.--
                               group data stream
                               to be inserted
                          memptr
                               NULL or pointer to er.sub.-- data.sub.-- group
                               data stream to
                               be inserted
                          handle
                               Handle to Builder's Control Block
               file data group
                          Adds a complete self-contained File Data Group unit
                          to the
                          EDMM Data Stream.
                          id   NO.sub.-- ID (ignored)
                          action
                               NONE
                          action
                               NONE
                          data NULL (ignored)
                          filename
                               NULL or filename of file.sub.-- data.sub.--
                               group data stream
                               to be inserted
                          memptr
                               NULL or pointer to file data.sub.-- group data
                               stream to
                               be inserted
                          handle
                               Handle to Builder's Control Block
    ABNORMAL.sub.-- END
               Caller is requesting an abnormal end to the build process
               before the end of
               the data stream has been reached. The Builder function dumps
               any CDF data
               already created into a diagnostic file.
               id         NO.sub.-- ID (ignored)
               action     NONE (ignored)
               data       NULL (ignored)
               filename   NULL (ignored)
               memptr     Ignored on input. Data Stream.
               handle     Handle to Builder's Control Block
    WRITE.sub.-- MEM
               Writes the Common Data Format Data Stream to one contiguous
               block of
               memory and returns the address. Memory is allocated by the
               builder. This
               function can only be successfully executed once for each
               Common Data Format
               Data Stream. After this call has been made, there are no other
               valid calls to the
               Builder that reference the current CDF data stream.
               id      NO.sub.-- ID (ignored)
               action  NONE (ignored)
               data    NULL (ignored)
               filename
                       NULL (ignored)
               memptr
                     Ignored on input. Data Stream.
               handle
                     Handle to Builder's Control Block
    WRITE.sub.-- FILE
               Writes the Common Data Format Data Stream to a file. The
               Builder opens the
               file, writes the Common Data Format Data Stream to the file,
               and closes the file.
               The file's name is specified by the caller by the filename
               input parameter. This
               function can only be successfully executed once for each
               Common Data Format
               Data Stream. After this call has been made, there are no other
               valid calls to the
               Builder that reference the current CDF data stream.
               id      NO.sub.-- ID (ignored)
               action  NONE (ignored)
               data    NULL (ignored)
               filename
                     Name of the file to which the Builder writes the Common
                     Data Format
                     Data Stream.
               memptr
                     NULL (ignored)
               handle
                     Handle to Builder's Control Block
    __________________________________________________________________________

    ______________________________________
           sc = egppp100 (function.sub.-- id,
               cdf.sub.-- file,
               &cdf.sub.-- mem,
               &handle,
               &id,
               &action,
               &data,
               cc);
    ______________________________________

    ______________________________________
    int egppp100(
    unsigned short
                  IN:      Function to perform
    function.sub.-- id,
    char *filename,
                  IN:      Name of file with CDF data
    char **memptr,
                  INOUT:   Ptr to CDF data in memory
    P.sub.-- HNDL *handle,
                  INOUT:   Ptr to persistent data
    short *id,    OUT:     Parsed unit's id
    short *action,
                  OUT:     Parsed unit's action
    UNITDATA *data,
                  OUT:     Parsed unit's data
    char *cc)     OUT:     Condition code
    ______________________________________

    __________________________________________________________________________
    FIRST      Parse the first CDF unit from the data stream. This function
               is only issued
               once during the parsing of a CDF data stream. The only units
               the caller
               can expect from a FIRST call appear below. These units are the
               "header"
               units in the data stream. Their actions are always NONE and
               they have no
               data. If any other unit appears first in the data stream, the
               Parser terminates
               with an "invalid data stream" condition code. Following is a
               list of the
               input and output data associated with a FIRST call:
               Edmm Data Stream
                          The common Data Format Data Stream being parsed
                          may contain Function, FR and File data.
                          function.sub.-- id
                                    FIRST
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data stream in memory
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        EDMM.sub.-- DATA.sub.-- STREAM.sub.-- ID
                          action    None
                          data      NULL (fields in structure are empty)
               E/R Data Group       The Common Data Format Data Stream being
                                    parsed
                                    contains E/R data
                                    function.sub.-- id FIRST
                          filename  Name of file containing CDF data stream
                                    (opened by Parser)
                          memptr    Pointer to CDF data stream in memory
                                    (updated as stream is parsed)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (fields in structure are empty)
               File Data Group
                          The Common Data Format Data Stream being parsed
                          contains File data
                          function.sub.-- id FIRST
                          filename  Name of file containing CDF data stream
                                    (opened by Parser)
                          memptr    Pointer to CDF data stream in memory
                                    (updated as stream is parsed)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (fields in structure are empty)
    NEXT       Parse the next unit from the CDF data stream. This function
               presumes that
               a position has already been established in the stream via the
               FIRST
               function. If positioning has not already been established, the
               Parser returns
               with an error, but the user has the ability to then issue a
               FIRST to correct
               the problem. The unit returned contains an id, action, and
               data portion, if
               data exists for that unit. Following is a list of the input
               and output data
               associated with a Parser NEXT function:
               Function Call
                          The CDF data stream contains a function call data
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FUN.sub.-- CALL.sub.-- ID
                          action    NONE
                          data
                                      name = fun.sub.-- name
                                      value = NULL (empty)
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
               Function Parameter
                          Function Call data in data stream contains
                          function
                          parameter data
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FUN.sub.-- PARM.sub.-- ID
                          action    NONE
                          data
                                      name = fun.sub.-- parm.sub.-- name
                                      value = fun.sub.-- parm.sub.-- value
                                      temp.sub.-- key = NULL (ignored)
                                      rel.sub.-- posn = NULL (ignored)
               ER Data Group
                          The CDF data stream contains E/R data
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (empty)
               Template   E/R data in data stream contains template instance
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        TEMPL.sub.-- ID
                          action
                                      CREATE
                                      READ
                                      UPDATE
                                      DELETE
                          data
                                      name = template.sub.-- name
                                      value = NULL (empty)
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
               Template Key
                          Template instance in data stream contains template
                          key
                          (temporary or real)
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        TEMP.sub.-- TMPL.sub.-- KEY.sub.-- ID
                          action    NONE
                          data
                                      name = NULL (empty)
                                      value = NULL (empty)
                                      temp.sub.-- key = temp.sub.-- key
                                      rel.sub.-- posn = NULL (empty)
                          OR
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        TMPL.sub.-- KEY.sub.-- ID
                          action    NONE
                          data
                                      name = NULL (empty)
                                      value = key.sub.-- value
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
                          Field     Template instance in data stream contains
                                    field
                                    function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FILED.sub.-- H)
                          action
                                      CREATE
                                      READ
                                      UPDATE
                                      DELETE
                          data
                                      name = field.sub.-- name
                                      value = field.sub.-- value
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
               Rel        E/R data in data stream contains relationship
                          instance
                          (two allowable variations)
                          function.sub.-- id NEXT
                          filename
                               Name of file containing CDF data stream
                          memptr
                               Pointer to CDF data in memory (updated
                               from previuos parse)
                          handle
                               Pointer to Parser's persistent data control
                               block
                          id   REL.sub.-- H)
                          action
                                      CREATE
                                      READ
                                      DELETE
                          data
                                      name = NULL (empty)
                                      value = NULL (empty)
                                      temp.sub.-- key = rel.sub.-- key
                                      rel.sub.-- posn = NULL (empty)
                          OR
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        OREL.sub.-- ID
                          action
                                      CREATE
                                      UPDATE
                          data
                                      name = NULL (empty)
                                      value = NULL (empty)
                                      temp.sub.-- key = rel.sub.-- key
                                      rel.sub.-- posn = rel.sub.-- posn
               relent key Relationship in data stream has source/target that
                          is
                          entity instance
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        RELENT.sub.-- KEY ID
                          action    NONE
                          data
                                      name = template.sub.-- name
                                      value = NULL (empty)
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
               relrel key Relationship in data stream has source/target that
                          is
                          relationship instance



                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        RELREL.sub.-- KEY.sub.-- ID
                          action    NONE
                          data
                                      name = NULL (empty)
                                      value = NULL (empty)
                                      temp.sub.-- key = rel.sub.-- key
                                      rel.sub.-- posn = NULL (empty)
               file data group
                          The CDF data stream contains file data
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous parse)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (empty)
               line       File data in data stream contains line data
                          function.sub.-- id NEXT
                          filename  Name of file containing CDF data stream
                          memptr    Pointer to CDF data in memory (updated
                                    from previous group)
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        LINE.sub.-- ID
                          action    NONE
                          data
                                      name = NULL (empty)
                                      value = line.sub.-- value
                                      temp.sub.-- key = NULL (empty)
                                      rel.sub.-- posn = NULL (empty)
    PREVIOUS   Return unit data for previous unit parsed from CDF data
               stream. This
               function presumes that a position has already been established
               in the stream
               via a FIRST function. If positioning has not already been
               established, the
               Parser returns with an error, but the user has the ability to
               then issue a
               FIRST to correct the problem. The unit returned is the unit
               that has JUST
               been parsed; that is, the caller can only go back ONE unit.
               The unit
               returned contains an id, action, and data portion, if data
               exists for that unit.
               Any unit may be returned as a result of the Parser PREVIOUS
               function.
               Refer to the lists of units for FIRST or NEXT for the complete
               list.
    SKIP       Skips the unit previously parsed from the CDF data stream.
               Again, this
               function presumes that a position has already been established
               in the stream
               via a FIRST function. This function does not return any unit
               data. Rather,
               it simply skips the unit that has JUST been parsed; successive
               SKIP calls to
               the Parser do NOT result in several units being skipped, but
               only succeed in
               skipping the same unit over and over. A SKIP call can be used
               to skip an
               entire nested unit of CDF data or a single unit of data
               (although skipping a
               single unit is an effective no-op).
    GET.sub.-- STREAM
               Copy the PREVIOUS unit parsede (including all of its imbedded
               units) into a
               separate file or memory location as specified by the caller.
               This call is
               issued when the caller has parsed an ER.sub.-- DATA.sub.--
               GROUP or
               FILE.sub.-- DATA.sub.-- GROUP unit and wants the entire E/R
               Data Group of File
               Data Group data stream imbedded within the CDF stream being
               parsed to
               be placed in a separate location for later access. The
               original data stream is
               not changed; the E/R or File data being copied is SKIPped in
               the original
               data stream so that parsing resumes at the unit following that
               imbedded
               stream.
                 The GET.sub.-- STREAM function cannot be issued on any units
               other
               than ER.sub.-- DATA.sub.-- GROUP and FILE.sub.-- DATA.sub.--
               GROUP and these units must
               have first been parsed by the caller. An attemp to issue
               GET.sub.-- STREAM on
               any other unit results in an error and the Parser will
               terminate.
                 Possible values sent to and returned from the Parser for
               GET.sub.-- STREAM are:
               E/R Data Stream
                          The E/R Data Gfroup, complete with imbedded
                          template and relationship data, is copied from the
                          CDF
                          data stream being parsed.
                          (IN) function.sub.-- id GET.sub.-- STREAM
                          (IN) filename
                                    Name of file which is to contain copied
                                    E/R Data Group data stream (NULL if data
                                    is to be copied to memory)
                          (IN/OUT) memptr
                                    Ignored upon input. Upon output
                                    and if filename is not specified,
                                    location in
                                    memory of E/R Data Group copied
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (fields in structure are empty)
                                    A subsequent NEXT on the original data
                                    stream yields the unit immediately
                                    following the entire
                                    E/R Data Group.
               File Data Group
                          The File Data Group, complete with imbedded lines,
                          is
                          copied from the CDF data stream being parsed.
                          (IN) function.sub.-- id GET.sub.-- STREAM
                          (IN) filename
                                    Name of file which is to contain copied
                                    File Data Group data stream (NULL if
                                    data
                                    is to be copied to memory)
                          (IN/OUT) memptr
                                    Ignored upon input. Upon output
                                    and if filename is not specified,
                                    location in
                                    memory of File Data Group copied
                          handle    Pointer to Parser's persistent data
                                    control
                                    block
                          id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID
                          action    NONE
                          data      NULL (fields in structure are empty)
                                      A subsequent NBXT on the original data
                                    stream yields the unit immediately
                                    following the entire
                                    E/R Data Group.
    ABNORMAL.sub.-- END
               Alerts Parser function that caller has experienced problem and
               that parsing
               is to be terminated on the CDF data stream currently being
               parsed. When
               this function is specified, the Parser does the necessary work
               to clean up all
               temporary and persistent data used during parsing. This
               enables the parsing
               process to begin cleanly for the same calling function on a
               new data stream.
               (Note: the processing done for this function is exactly the
               same as when the
               Parser reaches the end of the CDF data stream.)
    __________________________________________________________________________

    ______________________________________
    (In) CDF.sub.-- MEM          char*
    Parameters    Descriptions
    CDF.sub.-- MEM
                  Pointer to CDF data in memory.
    The invocation of the Free CDF function is as follows:
     char *cdf.sub.-- mem;
     short sc;
      . . .
     egppafre (cdf.sub.-- mem);
    ______________________________________
     Note:
     The equivalent function, egphafre e, exists on the host for users of EDMM

    ______________________________________
    Interface
    EDMM Communication Facility Interface
    ______________________________________
    (In) CDF.sub.-- FILE       char 47
    (In/Out) CDF.sub.-- MEM    char *
    (Out) SC                   short
    (Out) CC                   char 9
    ______________________________________
    Parameters Descriptions
    ______________________________________
    CDF.sub.-- FILE
               Name of work station file containing CDF
               data stream. (Opened and closed in this
               function.) CDF.sub.-- FILE and
               CDF.sub.-- MEM are mutually
               exclusive. See the description
               of CDF.sub.-- MEM for more information
               about the CDF data stream content.
                When the EDMM Communication Facility
               returns control to the caller, the
               output CDF data stream will usually
               be in memory (i.e., pointed to by
               CDF.sub.-- MEM). However, if sufficient
               memory is not available, the CDF data
               stream will be written to a file, and
               CDF.sub.-- MEM will return a NULL
               value. As currently implemented, the
               output CDF file is allocated within this
               function and the name is hard-coded as
               EGPPTCDF.OUT.
    CDF.sub.-- MEM
               Work station address of CDF data stream
               in memory. CDF.sub.-- FILE and CDF.sub.-- MEM
               are mutually exclusive: The caller of this
               function will use the Builder to create a CDF
               data stream that contains information on the
               function to be invoked on the host and its
               parameters, possibly including an imbedded
               CDF data stream containing file or E/R data
               units.
                As an output parameter, CDF.sub.-- MEM points
               to a CDF data stream that contains output
               parameters returned by the host function that
               was invoked on behalf of the caller. Again,
               depending on the host function interface, the
               CDF data stream may also include an
               imbedded CDF data stream containing file or
               E/R data units.
                The caller will use the Parser to retrieve
               this information from the CDF data stream.
    SC         Return code representing processing results
    CC         Condition code representing processing results
    ______________________________________

    ______________________________________
    #include prototype function calls for EDMM, Builder and Parser
    sc = egppt00 (cdf.sub.-- file,
    &cdf.sub.-- mem,
    cc);
    ______________________________________

    ______________________________________
    Interface
    Load.sub.-- BB Interface
    ______________________________________
    (In) CDF.sub.-- MEM   Fixed   32
    (In) CDF.sub.-- FILE  Char    46
    (Out) SC              Fixed   16
    (Out) CC              Char     8
    ______________________________________
    Parameters   Descriptions
    ______________________________________
    CDF.sub.-- MEM
                 Host memory location of CDF data
                 stream containing E/R data to be added,
                 deleted, or updated in the repository.
                 Caller will use the Builder function to
                 put data to be loaded in a CDF data
                 stream.
    CDF.sub.-- FILE
                 Host file containing CDF data stream
    SC           Severity code reflecting processing results
    CC           Condition code reflecting processing
                 results
    ______________________________________
     Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.

    ______________________________________
    Interface
    Unload.sub.-- BB Interface
    ______________________________________
    (In) SYSKEY           Fixed   31
    (Out) CDF.sub.-- MEM  Fixed   32
    (Out) CDF.sub.-- FILE Char    46
    (Out) SC              Fixed   16
    (Out) CC              Char     8
    ______________________________________
    Parameters  Descriptions
    ______________________________________
    SYSKEY      System-assigned key of the aggregation
                instance to be unloaded.
    CDF.sub.-- MEM
                Host memory location of CDF data
                stream containing the E/R data retrieved
                from the repository. Caller will use the
                Parser function to extract the data from
                the CDF data stream.
    CDF.sub.-- FILE
                Host file name of CDF data stream
                containing the E/R data retrieved from
                the repository. Caller will use the Parser
                function to extract the data from the
                CDF data stream.
    SC          Severity code reflecting processing results
    CC          Condition code reflecting processing results
    ______________________________________
     Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.

    ______________________________________
    Interface
    Copy.sub.-- BB Interface
    ______________________________________
    (In) SYSKEY           Fixed   31
    (In) TRG.sub.-- NAME  Char    32
    (In) TRG.sub.-- QLFR  Char     8
    (In) TRG.sub.-- LVL   Char     2
    (Out) SC              Fixed   16
    (Out) CC              Char     8
    ______________________________________
    Parameters    Descriptions
    ______________________________________
    SYSKEY        System-assigned key of the aggregation
                  instance to be copied.
    TRG.sub.-- NAME
                  Name of target aggregation instance
    TRG.sub.-- QLFR
                  Qualifier of target aggregation instance
    TRG.sub.-- LVL
                  Level of target aggregation instance
    SC            Severity code reflecting processing
                  results
    CC            Condition code reflecting processing
                  results
    ______________________________________

    ______________________________________
    Interface
    Delete.sub.-- BB Interface
    ______________________________________
    (In) SYSKEY           Fixed   31
    (Out) SC              Fixed   16
    (Out) CC              Char     8
    ______________________________________
    Parameters  Descriptions
    ______________________________________
    SYSKEY      System-assigned key of the aggregation
                instance to be deleted.
    SC          Severity code reflecting processing results
    CC          Condition code reflecting processing results
    ______________________________________

                                      TABLE I
    __________________________________________________________________________
    EDMM Builder Parser State Table
                            Next
    State
       CDF Unit/Builder/Parser Action
                            State
                               Description
    __________________________________________________________________________
     0 EDMM.sub.-- DATA/STREAM/FIRST
                             1 Initial Start State.
       ER.sub.-- DATA.sub.-- GROUP/FIRST
                            24
       FILE.sub.-- DATA.sub.-- FROUP/FIRST
                            31
     1 FUN.sub.-- CALL/NEXT  2 Processing an
       EDMM.sub.-- DATA.sub.-- STREAM/SKIP
                             0 edmm.sub.-- data.sub.-- stream.
     2 FUN.sub.-- CALL/NEXT  2 Processing a function call.
       FUN.sub.-- PARM/NEXT  2
       ER.sub.-- DATA.sub.-- GROUP/NEXT
                             3
       ER.sub.-- DATA.sub.-- GROUP/ADD.sub.-- STREAM
                            25
       FUN.sub.-- CALL/SKIP 26
       FILE.sub.-- DATA.sub.-- GROUP/NEXT
                            33
       FILE.sub.-- DATA.sub.-- GROUP/ADD.sub.-- STREAM
                            35
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
     3 TMPL/NEXT             4 Processing an er.sub.-- data.sub.-- group
       REL/NEXT              7 that is paired with a
       OREL/NEXT            36 function.sub.-- call. (Root is an
       ER.sub.-- DATA.sub.-- GROUP/SKIP
                             2 edmm.sub.-- data.sub.`3 stream
       ER.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM
                             2
     4 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                             5 Processing a template,
       TMPL.sub.-- KEY/NEXT  5 (Root is an
       TMPL/SKIP            27 edmm.sub.-- data.sub.-- stream)
     5 FUN.sub.-- CALL/NEXT  2 Processing the a template
       TMPL/NEXT             4 key list of a template. (Root
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                             5
       TMPL.sub.-- KEY/NEXT  5
       FIELD/NEXT            6
       REL/NEXT              7
       OREL/NEXT            36
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
     6 FUN.sub.-- CALL/NEXT  2 Processing a field list of a
       TMPL/NEXT             4 template. (Root is an
       FIELD/NEXT            6 edmm.sub.-- data.sub.-- stream)
       REL/NEXT              7
       OREL/NEXT            36
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
     7 RELREL.sub.-- KEY/NEXT
                             8 Processing a rel. (Root is an
       RELENT.sub.-- KEY/NEXT
                             9 edmm.sub.-- data.sub.-- stream)
       REL/SKIP             27
     8 RELREL.sub.-- KEY/NEXT
                            11 Processing a relrel.sub.-- key
       RELENT.sub.-- KEY/NEXT
                            12 which is the source key of a
                               rel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
     9 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            10 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 10 which is the source key of a
       RELENT.sub.-- KEY/SKIP
                            28 rel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    10 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            10 Processing the template key
       TMPL.sub.-- KEY/NEXT 10 list of a relent.sub.-- key. The
       RELREL.sub.-- KEY/NEXT
                            11 relent.sub.-- key is the source key
       RELENT.sub.-- KEY/NEXT
                            12 of a rel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    11 FUN.sub.-- CALL/NEXT  2 Processing a relrel.sub.-- key
       TMPL/NEXT             4 which is the target key of a
       REL/NEXT              7 rel. (Root is an
       OREL/NEXT            36 edmm.sub.-- data.sub.-- stream)
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    12 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            13 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 13 which is the target key of a
       RELENT.sub.-- KEY/SKIP
                            27 rel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    13 FUN.sub.-- CALL/NEXT  2 Processing the template key
       TMPL/NEXT             4 list of a relent.sub.-- key. The
       REL/NEXT              7 relent.sub.-- key is the target key
       OREL/NEXT            36 of a rel. (Root is an
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            13 edmm.sub.-- data.sub.-- stream)
       TMPL.sub.-- KEY/NEXT 13
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    14 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            15 Processing a template.
       TMPL.sub.-- KEY/NEXT 15 (Root is an er.sub.-- data.sub.-- group)
       TMPL/SKIP            29
    15 TMPL/NEXT            14 Processing the a template
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            15 key list of a template. (Root
       TMPL.sub.-- KEY/NEXT 15 is an er.sub.-- data.sub.-- group)
       FIELD/NEXT           16
       REL/NEXT             17
       OREL/NEXT            37
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    16 TMPL/NEXT            14 Processing a field list of a
       FIELD/NEXT           16 template. (Root is an
       REL/NEXT             17 er.sub.-- data.sub.-- group)
       OREL/NEXT            37
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    17 RELREL.sub.-- KEY/NEXT
                            18 Processing a rel. (Root is an
       RELENT.sub.-- KEY/NEXT
                            19 er.sub.-- data.sub.-- group
       REL/SKIP             29
    18 RELREL.sub.-- KEY/NEXT
                            21 Processing a relrel.sub.-- key
       RELENT.sub.-- KEY/NEXT
                            22 which is the source key of a
                               rel. (Root is an
                               er.sub.-- data.sub.-- group)
    19 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            20 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 20 which is the source key of a
       RELENT.sub.-- KEY/SKIP
                            30 rel. (Root is an
                               er.sub.-- data.sub.-- group)
    20 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            20 Procesing the template key
       TMPL.sub.-- KEY/NEXT 20 list of a relent.sub.-- key. The
       RELREL.sub.-- KEY/NEXT
                            21 relent.sub.-- key is the source key
       RELENT.sub.-- KEY/NEXT
                            22 of a rel. (Root is an
                               er.sub.-- data.sub.-- group)
    21 TMPL/NEXT            14 Processing a relrel.sub.-- key
       REL/NEXT             17 which is the target key of a
       OREL/NEXT            37 rel. (Root is an
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 er.sub.-- data.sub.-- group)
    22 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            23 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 23 which is the target key of a
       RELENT.sub.-- KEY/SKIP
                            29 rel. (Root is an
                               er.sub.-- data.sub.-- group)
    23 TMPL/NEXT            14 Processing the template key
       REL/NEXT             17 list of a relent.sub.-- key. The
       OREL/NEXT            37 relent.sub.-- key is the target key
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            23 of a rel. (Root is an
       TMPL.sub.-- KEY/NEXT 23 er.sub.-- data.sub.-- group)
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    24 TMPL/NEXT            14 Processing an er.sub.-- data.sub.-- group
       REL/NEXT             17 that is root unit.
       OREL/NEXT            37
       ER.sub.-- DATA.sub.-- GROUP/SKIP
                             0
       ER.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM
                             0
    25 FUN.sub.-- CALL/NEXT  2 Processing an er.sub.-- data.sub.-- group
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 that is a complete stream.
                               It is paired with a
                               function.sub.-- call. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    26 ER.sub.-- DATA.sub.-- GROUP/NEXT
                             3 Processing a SKIP to the
       FUN.sub.-- CALL/NEXT  2 end of a function call.
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 (Root is an
                               edmm.sub.-- data.sub.-- stream)
    27 FUN.sub.-- CALL/NEXT  2 Processing a SKIP to the
       TMPL/NEXT             4 end of a template, or
       REL/NEXT              7 relation unit. (Root is an
       OREL/NEXT            36 edmm.sub.-- data.sub.-- stream)
       FINAL.sub.--l STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    28 RELREL.sub.-- KEY/NEXT
                            11 Processing a SKIP to the
       RELENT.sub.-- KEY/NEXT
                            12 end of a relent source key of
                               a rel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    29 TMPL/NEXT            14 Processing a SKIP to the
       REL/NEXT             17 end of a template, or
       OREL/NEXT            37 relation unit. (Root is an
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 er.sub.-- data.sub.-- group)
    30 RELREL.sub.-- KEY/NEXT
                            21 Processing a SKIP to the
       RELENT.sub.-- KEY/NEXT
                            22 end of a relent source key of
                               a rel. (Root is an
                               er.sub.-- data.sub.-- group)
    31 FILE.sub.-- DATA.sub.-- GROUP/SKIP
                             0 Processing a file.sub.-- data.sub.-- group
       FILE.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM
                             0 which is root unit.
       LINE/NEXT            32
    32 LINE/NEXT            32 Processing a line of a
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 file.sub.-- data.sub.-- group. (Root is a
                               file.sub.-- data.sub.-- group.)
    33 FILE.sub.-- DATA.sub.-- GROUP/SKIP
                             2 Processing a
       FILE.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM
                             2 file.sub.-- data.sub.-- group. It is paired
       LINE/NEXT               with a function call. (Root
                               is an edmm.sub.-- data.sub.-- stream)



    34 FUN.sub.-- CALL/NEXT  2 Processing a line of a
       LINE/NEXT            34 file.sub.-- data.sub.-- group. (Root is an
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 edmm.sub.-- data.sub.-- stream)
    35 FUN.sub.-- CALL/NEXT  2 Processing a file.sub.-- data.sub.-- group
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0 which is a complete strem.
                               It is paired with a
                               function call. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    36 RELREL/NEXT          38 Processing an orel. (Root is
       RELENT/NEXT          39 an edmm.sub.-- data.sub.-- stream)
       OREL/SKIP            27
    37 RELREL/NEXT          43 Processing an orel. (Root is
       RELENT/NEXT          44 an er.sub.-- data.sub.-- group)
       OREL/SKIP            29
    38 RELENET.sub.-- KEY/NEXT
                            41 Processing a relrel.sub.-- key
                               which is the source key of
                               an orel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    39 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            40 Processing a relent key
       TMPL.sub.-- KEY/NEXT 40 which is the source key of
       RELENT.sub.-- KEY/SKIP
                            40 an orel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    40 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            40 Processing the template key
       TMPL.sub.-- KEY/NEXT 40 list of a relent.sub.-- key. The
       RELENET.sub.-- KEY/NEXT
                            41 relent.sub.-- key is the source key
                               of an orel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    41 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            42 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 42 which is the target key of an
       RELENT.sub.-- KEY/SKIP
                            27 orel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    42 FUN.sub.-- CALL/NEXT  2 Processing the template key
       TMPL.sub.-- NEXT      4 list of a relent.sub.-- key. The
       REL/NEXT              7 relent key is the terget key
       OREL/NEXT            36 of an orel. (Root is an
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            42 edmm.sub.-- data.sub.-- stream)
       TMPL.sub.-- KEY/NEXT 42
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    43 RELENT.sub.-- KEY/NEXT
                            46 Processing a relrel.sub.-- key
                               which is the source key of
                               an orel. (Root is an
                               er.sub.-- data.sub.-- group)
    44 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            45 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 45 which is the source key of
       RELENT.sub.-- KEY/SKIP
                            48 an orel. (Root is an
                               er.sub.-- data.sub.-- group)
    45 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            45 Processing the template key
       TMPL.sub.-- KEY/NEXT 45 list of a relent.sub.-- key. The
       RELENT.sub.-- KEY/NEXT
                            46 relent.sub.-- key is the source key
                               of an orel. (Root is an
                               er.sub.-- data.sub.`3 group)
    46 TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            47 Processing a relent.sub.-- key
       TMPL.sub.-- KEY/NEXT 47 which is the target key of an
       RELENT.sub.-- KEY/SKIP
                            29 orel. (Root is an
                               er.sub.-- data.sub.-- group)
    47 TMPL/NEXT            14 Processing the template key
       REL/NEXT             17 list of a relent.sub.-- key. The
       OREL/NEXT            317
                               relent key is the target key
       TEMP.sub.-- TMPL.sub.-- KEY/NEXT
                            47 of an orel. (Root is an
       TMPL.sub.-- KEY/NEXT 47 er.sub.-- data.sub.-- group)
       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE
                             0
    48 RELENT.sub.-- KEY/NEXT
                            46 Processing a SKIP to the
                               end of a relent source key of
                               an orel. (Root is an
                               er.sub.-- data.sub.-- group)
    49 RELENT.sub.-- KEY/NEXT
                            41 Processing a SKIP to the
                               end of a relent source key of
                               an orel. (Root is an
                               edmm.sub.-- data.sub.-- stream)
    __________________________________________________________________________

    ______________________________________
    Function Name: DELETE
    ______________________________________
    (In) SYSKEY        Fixed   31
    (In) AGG.sub.-- TYPE
                       Char    32
    (In) COMMIT        Char    1
    (Out) SC           Fixed   16
    (Out) CC           Char    8
    ______________________________________

                                      TABLE 2
    __________________________________________________________________________
    Building CDF Data Stream
                         Data-->Name
                         Data-->Value
    Builder              Data-->Temp.sub.-- Key
    Function
          ID        Action
                         Data-->Rel.sub.-- Posn
                                    Notes
    __________________________________________________________________________
    FIRST EDMM.sub.-- DATA.sub.--
                    NONE --         Tells the Builder
          STREAM.sub.-- ID
                         --         to build a CDF
                         --         data stream for
                         --         EDMM
    NEXT  FUN.sub.-- CALL.sub.-- ID
                    NONE DELETE     Adds function
                         --         name to the
                         --         CDF data stream
                         --
    NEXT  FUN.sub.-- PARM.sub.-- ID
                    NONE SYSKEY     Adds SYSKEY
                         2022654    input parameter
                         --         to the CDF data
                         --         stream
    NEXT  FUN.sub.-- PARM.sub.-- ID
                    NONE AGG.sub.-- TYPE
                                    Adds
                         DLI.sub.-- DBD.sub.-- DEF
                                    AGG.sub.-- TYPE
                         --         input parameter to the
                         --         CDF data stream
    NEXT  FUN.sub.-- PARM.sub.-- ID
                    NONE COMMIT     Adds COMMIT
                         Y          input parameter
                         --         to the CDF data
                         --         stream
    WRITE.sub.--
          (ignored) (ignored)
                         --         Builder returns address
    MEM                  --         of the EDMM Data Stream.
                         --         (The WRITE.sub.-- FILE builder
                         --         function could also have been
                                    used . . . in this case the data
                                    is returned in a file specified
                                    by the caller.)
    __________________________________________________________________________
     Note:
     This table emphasizes the input parameters that pertain to this scenario.

                  TABLE 3
    ______________________________________
    Parsing Output CDF Data Stream
                            Data-->Name
                            Data-->Value
    Parser                  Data-->Temp.sub.-- Key
    Function
           ID           Action  Data-->Rel.sub.-- Posn
                                           Notes
    ______________________________________
    FIRST  EDMM.sub.-- DATA.sub.--
                        NONE    --
           STREAM.sub.-- ID     --
                                --
                                --
    NEXT   FUN.sub.-- CALL.sub.-- ID
                        NONE    DELETE
                                --
                                --
                                --
    NEXT   FUN.sub.-- PARM.sub.-- ID
                        NONE    SC
                                0
                                --
                                --
    NEXT   FUN.sub.-- PARM.sub.-- ID
                        NONE    CC
                                CC.sub.-- OK
                                --
                                --
    ______________________________________
     Note:
     This table only shows the output parameters that pertain to this scenario

    ______________________________________
    Function Name: MAINTAIN
    ______________________________________
    (In) SYSKEY        Fixed   31
    (In) AGG.sub.-- TYPE
                       Char    32
    (In) CDF.sub.-- MEM
                       Fixed   32
    (In) CDF.sub.-- FILE
                       Char    46
    (In) COMMIT        Char    1
    (Out) SC           Fixed   16
    (Out) CC           Char    8
    ______________________________________

                                      TABLE 4
    __________________________________________________________________________
    Building CDF Data Stream for Maintain
                           Data-->Name
                           Data-->Value
    Builder                Data-->Temp.sub.-- Key
    Function
          ID         Action
                           Data-->Rel.sub.-- Posn
                                      Notes
    __________________________________________________________________________
    FIRST EDMM.sub.-- DATA.sub.--
                     NONE  --         Tells the Builder
          STREAM.sub.-- ID --         to build a CDF
                           --         data stream for
                           --         EDMM
    NEXT  FUN.sub.-- CALL.sub.-- ID
                     NONE  MAINTAIN   Adds function
                           --         name to the
                           --         CDF data stream
                           --
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE  SYSKEY     Adds SYSKEY
                           1123009    input parameter
                           --         to the CDF data
                           --         stream
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE  AGG.sub.-- TYPE
                                      Adds
                           DLI.sub.-- DBD.sub.-- DEF
                                      AGG.sub.-- TYPE
                           --         input parameter to the
                           --         CDF data stream
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE  COMMIT     Adds COMMIT
                           Y          input parameter
                           --         to the CDF data
                           --         stream
    NEXT  ER.sub.-- DATA.sub.-- GROUP
                     NONE  --         If the ER.sub.-- DATA.sub.-- GROUP
                           --         has already been created, a build
                                      function
                           --         of ADD.sub.-- STREAM should be used to
                                      add
                           --         the complete ER.sub.-- DATA.sub.--
                                      GROUP data
                                      stream into the current data stream.
    NEXT  TEMPL.sub.-- ID
                     UPDATE
                           DLI.sub.-- DBD
                                      Adds template id to the
                           --         CDF data stream
                           --
                           --
    NEXT  TMPL.sub.-- KEY.sub.-- ID
                     NONE  --         Adds template key to
                           1123009    the CDF data stream
                           --
                           --
    NEXT  FIELD.sub.-- ID
                     UPDATE
                           ACCESS     Updtaes template field to the
                           HDAM       CDF data stream (These NEXT
                           --         calls continue for each Template
                           --         unit and Relationship)
    WRITE.sub.--
          (ignored)  (ignored)
                           --         Builder returns address of the
    MEM                    --         EDMM Data Stream. (The WRITE.sub.--
                                      FILE
                           --         builder function could also have been
                           --         used. In this case the data is returned
                                      in
                                      a file specified by the
    __________________________________________________________________________
                                      caller.)
     Note:
     This table emphasizes the input parameters that pertain to this scenario.

                  TABLE 5
    ______________________________________
    Parsing Output CDF Data Stream
    ______________________________________
    Parser ID            Action  Data->Name
                                           Notes
    Function                     Data->Value
                                 Data->
                                 Temp.sub.-- Key
                                 Data->
                                 Rel.sub.-- Posn
    FIRST  EDMM.sub.-- DATA.sub.--
                         NONE    --
           STREAM.sub.-- ID      --
                                 --
                                 --
    Parser ID            Action  Data->Name
                                           Notes
    Function                     Data->Value
                                 Data->
                                 Temp.sub.-- Key
                                 Data->
                                 Rel.sub.-- Posn
    NEXT   FUN.sub.-- CALL.sub.-- ID
                         NONE    MAINTAIN
                                 --
                                 --
                                 --
    NE