Automated Message Conversion for Heterogeneous Communication

• Convert data values stored in structured Ada types into sequences of bytes (write or convert down)
• Convert byte strings back into structured data values (read or convert up)

This mechanism (often referred to as marshalling) can be used to transmit data values (messages) between heterogeneous computers running software compiled by different compilation systems, especially computer architectures using different "endian-ness" or different floating-point formats. The message sender can call an interchange subprogram for the message¹s type to write its current value into a byte string. The sender will then transmit the byte string over some communication medium to a receiver that will read its value into a local data structure by calling the corresponding interchange procedure. Agreed-upon formats for predefined type values (that is, integers, reals, and bytes) are used to ensure that the receiver gets a data value identical to that of the sender even if the layout used by each local compiler is different. This mechanism generates pure Ada and is fully portable.

Example:

• Automates creation and maintenance of message interchange subprograms.
• Completely customizable to accept local predefined numerics, naming conventions, and optimization requirements.
• Fully compatible with TRW UNAS.
• Fully supports private and limited private types.
• Supports user-defined conversion of polylithic data structures (based on access types).
• Could be used as basis for an RPC mechanism.
• Analogous to Ada 95 stream attributes. Can be used to override them.

ATIG subprograms write composite data structures into the byte string one component at a time. The byte representation for each component is constructed by the Write procedure for the component type. Nested structures are thus "flattened" into a sequence of predefined leaf values through a sequence of calls to Write subprograms. The read process is analogous. Byte sequences are convert-ed into values and stored in the components of the local data structure. ATIG attempts to minimize the number of bytes in each type¹s representation, especially for unconstrained types where only useful data is carried into the stream.

Automated generation and consistency checking of interchange subprograms is provided by ATIG for the following kinds of types:

• Predefined types (Integer, Float, Duration, Character, String, Calendar.Time)
• User-defined discrete, real, and fixed-point types
• Constrained and unconstrained arrays with single and multiple indexes
• Simple, mutable discriminant, limited mutable discriminant, and nonmutable discriminant records
• Types declared in a generic package whose components reference both generic formal types and other nonformal types
• Subtypes and derived types of any of the above types
• Private types whose completion is any of the above types

Several transfer formats for the predefined leaf values can be defined to serve diverse purposes:

• A lean format can be defined for internal communication within one local area network.
• A more sophisticated format (such as XDR or OSI ASN.1 BER) can be used for external communication within a wide area network.
• A human-legible transfer format can be used for debugging systems under development.
• A transfer format suitable for storage of information in some database can also be defined.

The user can change formats by substituting a different implementation (body) for the package, pro-viding interchange of the predefined types. Two user commands are defined by ATIG. They can be invoked at the UNIX shell with a command line or via a GUI. These commands provide the capability to:

• Create, update, or verify the consistency of inter-change subprograms for a single type specified by the user.
• Create, update, or verify the consistency of inter-change subprograms for all types located in a specified set of Ada units.

Both commands will traverse the type hierarchy of any type to ensure that up-to-date interchange subprograms exist for all component types in the closure of the hierarchy.