Subclass 135	Subclass 136	Subclass 137
Translation of code

System for encoding units of entity/relationship data to include prefixes with codes for length, action, and unit identifier

5355493

Abstract

A method is 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 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 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. In a data processing system having stored units of entity/relationship data, a computer-implemented method comprising the steps of:

reading said units of entity/relationship data;

encoding the units of entity/relationship data into an er.sub.-- data element according to a set of grammatical rules wherein length represents a number of bytes or words and other terminal elements are arbitrary unique values; and

storing the er.sub.-- data element;

wherein the set of grammatical rules include: ##STR1##

2. The method of claim 1 further comprising the steps of:

determining the length of the er.sub.-- data element;

encoding er.sub.-- data into an er.sub.-- data.sub.-- group; and

storing the er.sub.-- data.sub.-- group;

wherein the grammatical rules further include:

    __________________________________________________________________________
    <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> [; and]
        [storing the er.sub.-- data.sub.-- group].
    __________________________________________________________________________

3. The method of claim 2, the system having stored data for function calls and parameters, further comprising the steps of:

encoding a function.sub.-- call from the function calls and parameters wherein fun.sub.-- name is a name of a function being invoked, fun.sub.-- parm.sub.-- name is a name of a function parameter, and fun.sub.-- parm.sub.-- value is a value of the parameter; and

storing the function.sub.-- call with the er.sub.-- data.sub.-- group;

wherein the set of grammatical rules further includes the rules:

    __________________________________________________________________________
    <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.
              <NULL>
    <fun.sub.-- parm>
              ::= length <no.sub.-- action> fun.sub.-- parm.sub.-- id
              fun.sub.-- parm.sub.-- name
                 fun.sub.-- parm.sub.-- value[; and]
        [storing the function.sub.-- call with the er.sub.-- data.sub.--
    group].
    __________________________________________________________________________

4. The method of claim 3, the system having data stored as lines in files having a plurality of records, further comprising the steps of:

reading the lines of a file;

encoding a file.sub.-- data.sub.-- group from the lines wherein line.sub.-- value refers to a record and length refers to a number of bytes in a element;

storing the file.sub.-- data.sub.-- group with the function.sub.-- call and the er.sub.-- data.sub.-- group;

wherein the set of grammatical rules includes:

    __________________________________________________________________________
    <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[; and]
        [storing the file.sub.-- data.sub.-- group with the function.sub.--
    call and the er.sub.-- data.sub.-- group].
    __________________________________________________________________________

5. The method of claim 4, further comprising the steps of:

encoding a cdf.sub.-- data.sub.-- stream from the er.sub.-- data.sub.-- group, file.sub.-- data.sub.-- group, and function.sub.-- call; and

storing the cdf.sub.-- data.sub.-- stream;

wherein the set of grammatical rules includes:

    __________________________________________________________________________
    <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>[;
                and]
       [storing the cdf.sub.-- data.sub.-- stream].
    __________________________________________________________________________

6. The method of claim 5 further comprising the step of transmitting the cdf.sub.-- data.sub.-- stream to a remote computer.

7. The method of claim 6 further comprising the step of parsing the cdf.sub.-- data.sub.-- stream in the remote computer into separate units of data.

8. The method of claim 7 further comprising the steps performed in the remote computer of:

detecting a function call;

routing the function call to a function processing means;

capturing output from the function processing means;

building the output into an output cdf.sub.-- data.sub.-- stream; and

transmitting the output cdf.sub.-- data.sub.-- stream to the system.

9. The method of claim 8 further comprising the step of parsing by the system of the output cdf.sub.-- data.sub.-- stream to recover the output.

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 call 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. Host 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 contains 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 work station, 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 work station.

The scenario is as follows:

1. The application on the work station 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 work station transfers the CDF data to the CDF 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, places them back into the CDF data stream to be returned to the CF function on the work station.

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 afer 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 lilt 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
                            D7D9D6C3
                                   0000000A
                                         0005D7E4
                                               E2C80000
    00000000
          00000000
                00000000
                      00000000
                            00000000
                                   00000000
    __________________________________________________________________________

In the following the hexadecimal/character representation of a CDF Data Stream is broken down unit. The prefix is the first 6 bytes. The length is the first 4 bytes of the prefix, the action is the next byte of the prefix, and the id is the last byte of the prefix. The rest of the line is the data (this is of varying length).

000000DE 0002

Length=222, action=0 (NONE), id=2 (E/R.sub.13 DATA.sub.-- GROUP.sub.-- ID), data=none.

0000002F 0403D7CSD9E2 D6D54040

Length=47, action=4 (READ), id=zz (TMPL.sub.-- ID), data=PERSON

0000000C 0005FI F2 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=A 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.sub.-- 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

The printable Parser output for this data stream is:

    ______________________________________
    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
    ______________________________________

Common Data Format

The Common Data Format (CDF) provides a consistent means of communicating data among host and work station functions. It supports communication of E/R instance data and file data. In addition, it allows work station users to indirectly invoke host functions and receive results of host function processing. The CDF will be formally described.

CDF Basic Format

The CDF consists of units of data used to represent entity, attribute, and relationship instance data, function call information including parameters, and file data. Each CDF unit has a self-describing prefix area followed by a variable-length data area. The prefix area contains 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 grammar is described below. Functions that deal with data in the CDF should not maintain or otherwise handle the CDF data stream directly; this information is maintained by the Builder and Parser functions. Note also that CDF data streams consist of binary and character data. The prefix area is represented in binary and the data area in character.

CDF Formal Grammar

This section contains a formal description of the CDF grammar. It shows the units that can make up a CDF data stream as well as the semantics that go along with those units. All CDF data streams must conform to this formal grammar in order to be processed by the Builder and Parser functions.

Standard Backus Naur Form (BNF) notation is used to document this description.

    __________________________________________________________________________
    <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.
                 <NULL>
    <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. updata .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
    __________________________________________________________________________

BUILDER

The purpose of the Builder Function is to build the CDF data stream one unit at a time. The units are built as specified by the FUNCTION.sub.-- ID passed in. This function ensures that the CDF data stream being built is valid; if the unit built is invalid, an appropriate return code is passed back to the caller.

The following is the interface to the builder:

    __________________________________________________________________________
    int egppb100(
    unsigned short function.sub.-- id,
                     IN:  Function to perform
    short id,        IN:  Unit's id
    short action,    IN:  Unit's action
    UNITDATA *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
    __________________________________________________________________________

Note: Data types UNITDATA and B.sub.-- HNDL are defined in the EGPBACDF H file. You must include this H file in your function that calls the BUILDER.

The purpose of this function is to build a CDF data stream one unit at a time. A unit is defined as an id, action, and data. A unit may be nested to contain other units. To build a nested structure, add the parent unit first, and then all of its dependents. The Builder has functions that work together to build a Common Data Format Data Stream, as well as functions that write the structure to memory or a file. The functions are as follows:

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
             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
    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)
             memptr
                  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.-- ID
             action
                    CREATE
                    UPDATE
             data
                    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
             id   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 ill 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.-- ID (ignored)
            action  NONE
            data    NULL (ignored)
            filename
                 NULL or file name 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 file name of file.sub.-- data.sub.-- group data
                 stream
                 to be inserted
            memptr
                 NULL or pointer to file.sub.-- 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 allocatcd 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 doses 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
    __________________________________________________________________________

Parser

The purpose of the Parser function is to retrieve data one unit at a time from a CDF data stream. The data stream is parsed as specified by the FUNCTION.sub.-- ID passed in. During parsing, this function ensures that the CDF data stream is valid; if the unit parsed is invalid, an appropriate return code is passed back to the caller.

The invocation of the Parser function is as follows:

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


__________________________________________________________________________
    int egppp100(
    unsigned short function.sub.-- id,
                      IN:  Function to perform
    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
    __________________________________________________________________________

The UNITDATA data type is defined in the EGPBACDF Header file. The UNITDATA type further defines the kinds of data that can be returned for a CDF unit; depending upon the type of unit parsed, its data portion will be in certain fields of this structure as specified in the Header file. This Header file must be included in any function that interacts with the CDF data stream in any way.

The purpose of this function is to parse a CDF data stream one unit at a time. A CDF unit is defined as having a length, id, action, and sometimes data. All but the length of the unit is returned to the caller from the Parser function. A unit may be nested to contain other units. When parsing, the caller receives units in the order they occur in the CDF data stream. Thus, the "nesting" unit is parsed before its nested "children" units. The caller has the option to skip these parent nesting units should that unit type not make sense to them.

In addition to simply parsing units from the data stream, the Parser also verifies the semantic correctness of the data stream at each step through parsing. If at any point during the parsing process the unit is invalid with respect to the unit previously parsed, or the unit's action is invalid for the particular unit, the parsing process terminates with an appropriate condition code to alert the caller of an invalid data stream.

When the Parser function reaches the end of the data stream, or when an ABNORMAL.sub.-- END function is specified, a warning code accompanied by an EOP condition code is returned to the caller.

The Parser function is intended to provide a complete package of functions that can be executed against the given CDF data stream. The functions and their descriptions are as follows:

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, E/R, 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   FIELD.sub.-- ID
              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 previous parse)
              handle
                   Pointer to Parser's persistent data control
                   block
              id   REL.sub.-- ID
              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.sub.-- 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 parse)
              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 skills 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 parsed (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.13 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 attempt 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 Group
              The E/R Data Group, 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 NEXT 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.)

Free CDF Function

The purpose of the Free CDF function is to discard CDF data stream memory.

Free CDF interface:

    ______________________________________
    (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 c, exists on the host for users of EDMM.

EDMM Communication Facility

The purpose of the EDMM Communication Facility is to enable a work station application to invoke a fully-integrated Repository Manager/MVS function on the host communicating all file and E/R data between the work station and host functions. The communication is achieved by an open/close Repository, Manager/MVS function that opens the Repository Manager, transfers the function interface, file, and E/R data to the host in a CDF data stream, invokes the host fully-integratcd RM host function specified in the data stream, returns the function interface and all data associated with the function call in a CDF data stream to the work station, and closes the Repository Manager/MVS. If no errors are encountered, output parameters and data, if any, for the host function, are returned to the caller in a CDF data stream.

    __________________________________________________________________________
    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 ouput 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
    __________________________________________________________________________

The invocation of the EDMM Communication Facility is as follows: #include prototype function calls for EDMM, Builder and Parser

    ______________________________________
             sc = egppt00
                      (cdf.sub.-- file,
                      &cdf.sub.-- mem,
                      cc);
    ______________________________________

Return codes are passed back in the CC and SC fields.

Productivity Facility

The Productivity Facility (PF) is the component that

enables the rapid creation of data manipulation facilities based on a variety of views of E/R data in the repository and

customizes the Communication Facility function.

The PF creates Repository Manager C-language functions described below.

Load.sub.-- BB: A function that interprets a CDF data stream containing entity, attribute, and relationship information. It updates the repository as specified by the action 1field of each CDF unit.

Unload.sub.-- BB: 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.

Copy.sub.-- BB; A function that copies a group of connected entity and relationship instances in the repository.

Delete.sub.-- BB: A function that deletes a group of connected entity and relationship instances from the repository.

Communication Facility: The host portion of (:F that enables the function routing to your RM functions.

Load BB

The Load.sub.-- BB function adds or updates a logical unit of data in the repository as specified by the CDF data stream. Data is passed in as template and relationship units in an ER data group.

Separate functions must be defined for each data view needed by the application (i.e. each different template tree).

Note: Currently this function does not obtain any locks or perform any commits. In situations where the data must be locked before update, a lock must be separately obtained on the necessary entity instance prior to invoking the load function. A Commit should be performed after invoking this function in order to make changes to the repository permanent.

    __________________________________________________________________________
    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.
           Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.
    CDF.sub.-- FILE
           Host file containing CDF data stream
    SC     Severity code reflecting processing results
    CC     Condition code reflecting processing results
    __________________________________________________________________________

Return codes are passed back in the CS and CC fields of the data stream. Since the Load.sub.-- BB functions are generated, each Load.sub.-- BB has the same set of possible return codes.

Unload.sub.-- BB

The Unload.sub.-- BB function retrieves a logical unit of data from the repository and puts it in CDF data stream. Data is returned as template and relationship units in an ER data group.

Separate functions must be defined for each data view needed by the application (i.e. each different template tree).

Note: Currently this function does not obtain any locks. To avoid a "dirty read" a lock must be obtained on the aggregation instance.

    __________________________________________________________________________
    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.
           Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.
    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
    __________________________________________________________________________

Host Function Invocation

Return codes are passed back in the CS and CC fields of the data stream. Since the Unload.sub.-- BB Functions are generated, each Unload.sub.-- BB has the same set of possible return codes.

Copy.sub.-- BB

The purpose of the Copy.sub.-- BB function is to allow the user to copy an entire object in the repository, storing the duplicate under another name. Any data view (i.e. a template tree) can can be copied using this function. The target of the Copy.sub.-- BB must not already exist. The Copy.sub.-- BB functions do not copy shareable subcomponents, but will create relationships to the shared subcomponents.

Note: As used herein all objects and shareable subcomponents have a root template with the following attributes: name, qualifier, and level. This function and its interface will have to be modified the data view does not conform to this naming standard.

Note: Currently this function docs not obtain any locks or perform any commits. To avoid a "dirty read" a lock must be obtained on the source aggregation instance. A Commit should be performed after invoking this function in order to make changes to the repository permanent. obtained to avoid a "dirty read".

    __________________________________________________________________________
    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
    __________________________________________________________________________

Return codes are passed back in the SC and CC fields of the data stream. Since the Copy.sub.-- BB functions are generated, each Copy.sub.-- BB has the same set of possible return codes.

Delete BB

The purpose of the Delete.sub.-- BB function is to enable the user to delete an object instance from the repository. This function can delete any data view (i.e. template tree). The Delete.sub.-- BB functions defined here do not delete shareable subcomponents, but will delete the relationships to the shared subcomponents. The Load function can be used to delete individual entity instances within an aggregation instance.

Note: Currently this function does not obtain any locks or perform any commits. A DELETE lock must be obtained on the aggregation instance before invoking the function. A Commit should be performed after invoking this function in order to make the delete permanent.

    __________________________________________________________________________
    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
    __________________________________________________________________________

Return codes are passed back in the SC and CC fields of the data stream. Since the Delete.sub.-- BB functions are generated, each Delete.sub.-- BB has the same set of possible return codes.

Builder-Parser State Tables

Documented below is a state table that describes the valid units and actions when parsing or building a CDF data stream.

                                      TABLE 1
    __________________________________________________________________________
    EDMM Builder/Parser State Table
                            Next
    State
       CDF Unit/Builder/Parser Action
                            State
                               Description
    __________________________________________________________________________
     0 EDMM.sub.-- DATA.sub.-- STREAM/FIRST
                             1 Initial Start State.
       ER.sub.-- DATA.sub.-- GROUP/FIRST
                            24
       FILE.sub.-- DATA.sub.-- GROUP/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.-- 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 is an edmm.sub.-- data.sub.-- stream)
       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 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 Processing 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 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.-- 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            34 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 stream.
                               It is paired with a
                               function.sub. -- 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 RELENT.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.sub.-- key
       TMPL.sub.-- KEY/NEXT 40 which is the source key of
       RELENT.sub.-- KEY/SKIP
                            49 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 relent.sub.-- key. The
       RELENT.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/NEXT             4 list of relent.sub.-- key. The
       REL/NEXT              7 relent.sub.-- key is the target 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.-- 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 relent.sub.-- key. The
       OREL/NEXT            317
                               relent.sub.-- 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 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)
    __________________________________________________________________________

PF/Creating Data Handling Functions

To create a data handling function, perform the following steps:

1. From RM select a private tool group as the current tool group.

2. From the main panel of RM enter the option to go to the Logical View (LV).

3. Select the option to make a copy of one of the base data handling functions to your own private function.

If you are creating a Load function put EGPLOAD as the source function name and put the name of the function that you wish to create as the target function name. To create an unload function use EGPUNLD, for copy use EGPCOPY and for delete use EGPDELT for the source function name.

4. After the function has been successfully copied return to the main LV panel and enter the name of the function you just added at the top of the panel.

5. Select the option to specify your function's templates. In each template that you add make sure you add an extra field named REL.sub.-- NAME that is CHAR 32 (Varying Length).

6. From the main LV panel select the option to create the connections between your templates. (Note: Your template tree can only have one root).

7. From the main LV panel select the option to change the program name from DWKLOGIC to the name of the file in which your function will reside (this can be identical to the name of the function) and change the programming language to C.

8. From the main LV panel select the option to bind the function.

9. From the main LV panel select the option to create the C-Language AIM file (H file) for the function.

10. From the main LV panel select the option to create a report on the new function.

11. Exit RM.

12. Run the EDMM-Productivity Facility program. Specify the System: CMS, MVS, etc. Specify the The FUNCTION type: UNLOAD, LOAD, DELETE, COPY, or CF.

a. 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.

This function takes any root key as input (i.e. dependent keys and/or user assigned keys).

b. 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.

c. Delete

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

d. Copy

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

e. CF

A function that provides data transfer and remote function routing between the work station and the host platforms.

Enter the function name (Ex. EDXUD00):

Enter the name of the function (this is the target function name used above). Enter the program name (Ex. EDXUD00C):

Enter the name of the program (this is the name that you specified earlier, it may be identical to the function name).

Enter the Aggregation name (Ex. DBD Definition):

Enter a string that names the object that the function operates on. It does not have to be a defined aggregation name.

UNLOAD generation complete . . . Source code is in RM120.EDMMSRC0(MYUNLOAD) LEL is in RM120.EDMMLEL0(MYUNLOAD)

If the function is successfully created a message will indicate where the newly created source code and lel file reside.

13. After the new data handling function has created, compile the function using the C/370 compiler.

14. Link Edit the new function.

FUNCTION INVOCATION EXAMPLES

This section describes the work station steps necessary for invoking the host functions via EDMM. This description is achieved by use or examples and comments describing the behavior. Each example illustrates the use of regular parameters (input and output), a scenario on building the data for EDMM and a scenario on parsing the data returned From the function via EDMM. There are four examples: the first example demonstrates the invocation of a function without any CDF data; the second example has CDF data as input to the host function; the third has CDF data returned back from the host function; and the last example includes the use of CDF data as input and output to the host function.

Function With No CDF Data

Following is the work station activity necessary to invoke a function (DELETE) that has no special CDF data. Assume that the DELETE function interface is as follows:

    ______________________________________
    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
    ______________________________________

1. The Builder is invoked multiple times to build the data stream EDMM. Note: Only input data needs to be put in the data stream. Output parameters do not need to be built into the data stream.

                                      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
    MEM                   --        address 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.

2. After creating the EDMM Data Stream, the EDMM communication function can be invoked:

rc=egppt00(cdf.sub.-- filename, & cdf.sub.-- memaddr, cc);

The cdf.sub.-- filename would be a null string in this case, since the EDMM Data Stream is in the memory block pointed to by cdf.sub.-- memaddr.

3. Upon completion of the DELETE function, egppt00 returns with an output EDMM Data Stream. This information can be read via multiple invocations of the parser.

Note: The caller must release time memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the steps necessary to read the data:

                                      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 With CDF Data as an Input Parameter

Following is the work station activity necessary to invoke a host function that requires CDF data as input. Assume that the function interface is as follows:

    ______________________________________
    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
    ______________________________________

1. Following are the steps necessary to build the data stream for EDMM. Note: Only input data needs to be put in the data stream.

                                      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
                           1123009   key to the CDF
                           --        data stream
                           --
    NEXT  FIELD.sub.-- ID
                     UPDATE
                           ACCESS    Updates template
                           HDAM      field to the CDF
                           --        data stream
                           --        (These NEXT
                                     calls continue for
                                     each Template
                                     unit and
                                     Relationship)
    WRITE.sub.--
          (ignored)  (ignored)
                           --        Builder returns
    MEM                    --        address 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.

It should be noted here that the CDF.sub.-- FILE and CDF.sub.-- MEM in the Maintain Parameter template actually refer to the host filename and the host memory location of the CDF data. Since it would be unnatural for the work station application to specify these values, the EDMM communication Facility recognizes the CDF data group associated with the function call and sets the host function parameters with the appropriate data.

2. After creating the EDMM Data Stream, the EDMM communication Facility can be invoked:

rc=egppt00 (cdf.sub.-- filename, &cdf.sub.-- memaddr, cc);

The cdf.sub.-- filename should be a null string in this case, since the EDMM Data Stream is in the memory block pointed to by cdf.sub.-- memaddr.

3. Upon return completion of the MAINTAIn Facility, egppt00 returns with an output EDMM Data Stream. This information can be read via the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the step necessary to read the data:

                                      TABLE 5
    __________________________________________________________________________
    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 MAINTAIN
                          --
                          --
                          --
    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 with CDF Data as an Output Parameter

Following is the work station activity necessary to invoke a host function that has CDF data as Output. Assume that the function interface is as follows:

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

1. Following are the steps necessary to build the data stream for EDMM.

                                      TABLE 6
    __________________________________________________________________________
    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
                     NONE   --        Tells the Builder
          STREAM.sub.-- ID  --        to build a CDF
                            --        data stream for
                            --        EDMM
    NEXT  FUN.sub.-- CALL.sub.-- ID
                     NONE   UNLOAD    Adds function
                            --        name to the
                            --        CDF data stream
                            --
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE   SYSKEY    Adds SYSKEY
                            6674001   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   LOCKTYPE  Adds
                            NOUPDATE  LOCKTYPE
                            --        input parameter
                            --        to the CDF data
                                      stream
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE   HOLDLOCK  Adds
                            N         HOLDLOCK
                            --        input parameter
                            --        to the CDF data
                                      stream
    WRITE.sub.--
          (ignored)  (ignored)
                            --        Builder returns
    FILE                    --        the data in a file
                            --        whose name is
                            --        specified by the
                                      caller. As in the
                                      example before,
                                      the data could
                                      have been placed
                                      in memory if the
                                      WRITE.sub.-- MEM
                                      function was
                                      employed.
    __________________________________________________________________________
     Note:
     This table emphasizes the input parameters that pertain to this scenario.

Once again, it should be noted here that the CDF.sub.-- FILE and CDF.sub.-- MEM parameters in the UNLOAD parameter list refer to the host filename and the host memory of the CDF data. Since it would be unnatural for the work station application to specify these values, the EDMM communication Facility recognizes the CDF data group associated with the function call and sets the host function parameters with the appropriate data.

2. After creating the EDMM Data Stream, the EDMM communication Facility can be invoked:

rc=egppt00 (cdf.sub.-- filename, & cdf.sub.-- memaddr, cc);

The cdf.sub.-- filename contains the name of the file that the user specified to the Builder for the WRITE.sub.-- FILE function. The cdf.sub.-- memptr should be set to NULL.

3. Upon completion of the MAINTAIn facility, egppt00 returns with an output EDMM Data Stream. This information can be read via the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the step necessary to read the data:

                                      TABLE 7
    __________________________________________________________________________
    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  UNLOAD
                           --
                           --
                           --
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     NONE  SC
                           0
                           --
                           --
    NEXT  FUN.sub.-- PARM.sub.-- ID
                     CC    CC.sub.-- OK
                           --
                           --
                           --
    NEXT  ER.sub.-- DATA.sub.-- GROUP
                     NONE  --
                           --
                           --
                           --
    NEXT  TEMPL.sub.-- ID
                     DLI.sub.-- DBD
                           --
                           --
                           --
                           --
    NEXT  TMPL.sub.-- KEY.sub.-- ID
                     NONE  DLI.sub.-- DBD
                           6674001
                           --
                           --
    NEXT  FIELD.sub.-- ID
                     NONE  NAME
                           DBDI
                           --
                           --
    NEXT  The rest of the
    `. . . `
          Templates and
          Relationships for the
          Aggregation Instance.
    __________________________________________________________________________
     Note:
     This table only show the output parameters that pertain to this scenario.

Function With CDF Data as Input and Output Parameters

Following is the work station activity necessary to invoke a host function that has CDF data as Output. Assume that the function interface is as follows:

    ______________________________________
    Function Name: SRCMEM
    ______________________________________
    (In) SRCLIB            Char    44
    (In/Out) CDF.sub.-- MEM
                           Fixed   32
    (In/Out) CDF.sub.-- FILE
                           Char    46
    (Out) SC               Fixed   16
    (Out) CC               Char     8
    ______________________________________

1. Following are the steps necessary to build the data stream for EDMM.