NAME

cxUnknownAlloc, cxUnknownCopy, cxUnknownCountGet, cxUnknownCountSet, cxUnknownDataGet, cxUnknownDataLen, cxUnknownDataRem, cxUnknownDataSet, cxUnknownDup, cxUnknownRead, cxUnknownWrite

interface routines for IRIS Explorer cxUnknown data structure

#include <cx/cxUnknown.api.h>
#ifndef __cxUnknown_API_H_
#define __cxUnknown_API_H_

#ifdef __cplusplus
 extern "C" {
#endif

#include <stdio.h>
#if defined(__sun) || defined(WIN32)
 cxUnknown* cxUnknownAlloc( signed long Count );
 cxUnknown* cxUnknownCopy( cxUnknown *src );
 signed long cxUnknownCountGet( cxUnknown *src, cxErrorCode *ec );
 void cxUnknownCountSet( cxUnknown *src, signed long val, cxErrorCode *ec );
 unsigned char* cxUnknownDataGet( cxUnknown *src, cxErrorCode *ec );
 long cxUnknownDataLen( cxUnknown *src, cxErrorCode *ec );
 void cxUnknownDataRem( cxUnknown *src, unsigned char* *val, cxErrorCode *ec );
 void cxUnknownDataSet( cxUnknown *src, unsigned char* val, cxErrorCode *ec );
 cxUnknown* cxUnknownDup( cxUnknown *src );
 cxUnknown* cxUnknownRead( FILE *fd );
 void cxUnknownWrite( FILE *fd, int mode, cxUnknown *src );
#ifndef __cxUnknown_API_H_
#define __cxUnknown_API_H_

#ifdef __cplusplus
 extern "C" {
#endif

#include <stdio.h>
#if defined(__sun) || defined(WIN32)
 integer function cxUnknownAlloc( Count )
 integer function cxUnknownCopy( src )
 integer function cxUnknownCountGet( src, ec )
 subroutine cxUnknownCountSet( src, val, ec )
 integer function cxUnknownDataGet( src, ec )
 integer function cxUnknownDataLen( src, ec )
 subroutine cxUnknownDataRem( src, val, ec )
 subroutine cxUnknownDataSet( src, val, ec )
 integer function cxUnknownDup( src )
 integer function cxUnknownRead( fd )
 subroutine cxUnknownWrite( fd, mode, src )
src
In C, a pointer to the data structure to be accessed in whole or part. In Fortran, an opaque integer handle to the data structure to be accessed in whole or part.
val
The val argument (if present) is the new value to be assigned to the structure member. See the section on Set routines below for more information on the val argument.
*Ind
Arguments following src and preceding ec with variable name ending in Ind (if any) are integer array bounds. If such an argument exists, the requested member is part of an array of structures, for which the *Ind variable provides the array index.
ec
In C, a pointer to a returned error code (if present). In Fortran, an integer output error code (if present). The ec output is an enumerated integer with cx_err_none (zero) indicating success. Any other value indicates an improper src input or an out-of-bounds Ind argument.
The return value (if present) is the accessed member, member type or length, allocated array or structure, duplicated structure, or read structure. See the section on the appropriate routines below for more information. The cxUnknown IRIS Explorer data structure is used to communicate data between modules in the IRIS Explorer scientific visualization system. The cxUnknown structure is defined using the IRIS Explorer Typing Language; the actual datatype specification is given at the bottom of the manual page. Derived from this datatype are several C and Fortran language routines that support manipulation of the cxUnknown structure members. The name of each routine is derived from the label of the associated member in the cxUnknown along with a keyword to denote the routine's action. Each routine name has the three parts type, member, and action, where type is either cxUnknown or a subsidiary reference-counted type, the optional member indicates the member to be accessed (or, if missing, indicates that the entire structure is the subject of the action), and action names the action the routine performs. Routines are generated to support only the actions which make sense for the cxUnknown structure. Not all types of routines may be represented if cxUnknown does not contain all types of structure members. Routines may be generated to support getting, setting and allocating structure members. Other routines compute the type, length, or array dimension product of appropriate structure members. Additional routines support copying, duplication, reading and writing of the entire cxUnknown data structure and of its subordinate reference counted sub-structures (if any). Similar routines are described together in a section below. Each description gives the information common to the routines in that section, with a table of the details particular to each routine. While the section headings mention only the cxUnknown routines, their discussions also pertain to similar routines for reference-counted types within cxUnknown. While most routines for the cxUnknown structure deal with the entire structure or a single member of it, some routines may access several members that have been aliased together (see, for instance, the data and coordinates arrays in the cxData and cxCoord structures of the cxLattice type). The routines that manipulate the non-uniquely labelled members in the cases of a switch structure have a special structure. Whereas a routine accessing a single structure member can have arguments and a return value of known type, the argument types of the union-based routine are not known at compile time. Therefore, such a routine expects as input or returns as output a pointer to memory; the pointer is either the pointer to the scalar member, or the actual member address in the case of an array or referenced structure. Some Get, Set, Type and Len routines may have this behavior. All of the routines documented above are automatically generated from the type file (whose suffix is .t). If you wish to examine the generated code for a given type (user- or IRIS Explorer-defined), you can recreate those files at will. Once you have created a .t file containing the type specification, you must also create a file named TYPES, which has on a single line the name of your type (without the .t suffix). Then create a Makefile by executing cxmkmf; you use the Makefile to build the type library. In the process of doing this, the generated code will be written to the file with suffix .api.c.

For example, assuming that the cxUnknown.t file exists, you would take the following steps:

        echo cxUnknown > TYPES
        cxmkmf
        make
Now your automatically generated code will reside in cxUnknown.api.c.

Note that this process will create several files in the local directory, so it is often helpful to use a separate directory for types, just as modules are developed in their own directories.

Routines in this group return the value of the appropriate structure member. The label of the member is used to construct the name of the routine, which has the three parts type, member, and Get. If the label refers to several members in disjoint cases of a switch statement, then the return value is a pointer to storage. This pointer is either a reference to the scalar member, or the actual member pointer, depending on the type of the member.
 signed long cxUnknownCountGet( cxUnknown *src, cxErrorCode *ec );
 unsigned char* cxUnknownDataGet( cxUnknown *src, cxErrorCode *ec );
 integer function cxUnknownCountGet( src, ec )
 integer function cxUnknownDataGet( src, ec )
<ans>
The returned argument represents the structure member of interest. There are two cases, with different interpretations of the returned argument. The first case, in which the return type is not a generic pointer (in C a void* pointer, in Fortran an integer), returns the member of interest, whether scalar or pointer. In the second case, in which the return type is a generic pointer (in C a void* pointer), the returned value is a pointer to storage. If the requested member is a scalar, the returned value is a reference to that scalar. If the requested member is a pointer, the returned value is actually that pointer. This case happens when several members in different cases of a switch structure are given the same label in the IRIS Explorer Typing Language file cxUnknown.t. It may be difficult to distinguish the two cases in Fortran based on the function return type (if that type is integer). In this case the user should consult the definition of cxUnknown to determine whether several members have the same label string. In Fortran, the Get routines that return a character string or array of character strings are implemented as subroutines having that string as their last argument. They are not written as character functions. Such a subroutine returning an array of character strings assumes the caller has passed in enough storage to hold all the strings; the number of elements necessary to form the array can be found by calling the related Len routine.
Routines in this group set the value of the appropriate structure member. The label of the member is used to construct the name of the routine, which has the three parts type, member, and Set. If the label refers to several members in disjoint cases of a switch statement, then the input value must be a pointer to storage. This pointer is either a reference to a scalar value used to override the old member value, or the actual pointer used to replace the member, depending on the type of the member. The old member is deleted, if an array, or has its reference count decremented, if a shared structure.
 void cxUnknownCountSet( cxUnknown *src, signed long val, cxErrorCode *ec );
 void cxUnknownDataSet( cxUnknown *src, unsigned char* val, cxErrorCode *ec );
 subroutine cxUnknownCountSet( src, val, ec )
 subroutine cxUnknownDataSet( src, val, ec )
val
The val argument (if present) is the new value to be assigned to the structure member. There are two cases, with different interpretations of val. The first case, in which the type of val is not a generic pointer (in C a void* pointer, in Fortran an integer), assigns val, whether scalar or pointer. In the second case, in which the type of val is a generic pointer (in C a void* pointer), val is a pointer to storage. If the requested member is a scalar, val is a reference to that scalar. If the requested member is a pointer, val is interpreted as actually that pointer. This case happens when several members in different cases of a switch structure are given the same label in the IRIS Explorer Typing Language file cxUnknown.t. It may be difficult to distinguish the two cases in Fortran based on the argument type (if that type is integer). In this case the user should consult the definition of cxUnknown to determine whether several members have the same label string.
Routines in this group return the type of the appropriate structure member, which is one of several members sharing the same label. The label of the member is used to construct the name of the routine, which has the three parts type, member, and Type. Routines in this group return the length in words of the appropriate array member. This length is calculated as the product of the dimensioning scalars and variables used to declare the array. The label of the member is used to construct the name of the routine, which has the three parts type, member, and Len.
 long cxUnknownDataLen( cxUnknown *src, cxErrorCode *ec );
 integer function cxUnknownDataLen( src, ec )
<ans>
The type of the requested switch discriminator variable. In C, the return value is a cxPrimType enumerated integer. In Fortran, the return value is an integer. See the file /usr/explorer/include/cx/Typedefs.h for more information.
Routines in this group compute the product of an array member's elements, to reflect the contribution to the length of an array that uses this member as a dimensioning variable. The label of the member to be allocated is used to construct the name of the routine, which has the three parts type, member, and Prod.
<ans>
The returned integer value is the length of an array dimensioned by the specified member, computed by taking the product of the member's values.
Routines in this group duplicate the entire data structure. The type of the structure is used to construct the name of the routine, which has the two parts type and Dup.
 cxUnknown* cxUnknownDup( cxUnknown *src );
 integer function cxUnknownDup( src )
<ans>
The return value references the duplicated structure, or is zero if an error was encountered. In C, the return value is a pointer to the structure. In Fortran, the return value is an opaque integer handle to the duplicated data structure.
Routines in this group copy the data structure, but not its reference counted children. The children of the input structure are referenced from the output structure and their reference counts incremented. For instance, a copied lattice would have a new cxLattice structure and a new dims vector, but would refer to the original cxData and cxCoord structures. The type of the structure is used to construct the name of the routine, which has the two parts type and Copy.
 cxUnknown* cxUnknownCopy( cxUnknown *src );
 integer function cxUnknownCopy( src )
<ans>
The return value references the copied structure, or is zero if an error was encountered. In C, the return value is a pointer to the structure. In Fortran, the return value is an opaque integer handle to the duplicated data structure.
Routines in this group allocate a reference-counted structure, an array member, or one of several union members sharing the same label. The label of the member to be allocated is used to construct the name of the routine, which has the three parts type, (optionally) member, and Alloc. If there is no member designated, the routine allocates the entire reference-counted structure.
 cxUnknown* cxUnknownAlloc( signed long Count );
 integer function cxUnknownAlloc( Count )
There are two types of allocation routines, those that allocate an array and those that allocate a reference-counted structure.
src
If src is an argument, then the allocation creates an array needed by the src structure. It is assumed that the src structure has been constructed to contain all the information needed to dimension the array. In C, src is a pointer to the structure. In Fortran, src is an opaque integer handle to the data structure.
<other>
The arguments other than src, if any, are dimensioning scalars, dimensioning arrays, and discriminating switches of some enumerated type. In C, the respective types of these arguments are long, long*, and enumerated types. In Fortran, their respective types are integer, integer array, and enumerated integer. These arguments are included in the argument list if they are needed to compute the size of an array or which case of a switch to take in allocating a reference-counted structure. It is possible that a structure allocation routine will not fully allocate the structure. This happens when an array or switch contains several items to also be allocated; there is no acceptable way to put all of the dimensioning information into the function call, so the array is not allocated (a null pointer is used instead) and the user is expected to use array allocation and member setting routines to complete the structure allocation. The return value references the allocated array or structure, or is zero if an error was encountered. In C, the return value is a pointer to the allocated structure. In Fortran, the return value is an opaque integer handle to the allocated data structure.
Routines in this group remove an array of objects, which may be scalars, structures, or reference-counted structures. Simple arrays are freed, arrays of structures are operated on recursively to remove their contents, and reference-counted structures have their reference counts decremented. The label of the member to be removed is used to construct the name of the routine, which has the three parts type, member, and Rem. No routine is created for removal of single reference-counted structures, use cxDataRefDec for that purpose. These routines are internal utilities used only by the Set routines. They are not meant for public use. No Fortran interface is provided. To delete a reference-counted object and the members it contains, use cxDataRefDec. To replace a member, use the related Set routine.
 void cxUnknownDataRem( cxUnknown *src, unsigned char* *val, cxErrorCode *ec );
src
src is the reference-counted structure containing the member to be removed. In C, src is a pointer to the structure.
val
val is the address of the member to be removed. An array is deleted, while a shared structure has its reference count decremented. In C, val is a pointer to the member.
Routines in this group use the IRIS Explorer transcription mechanism to read an ASCII or binary IRIS Explorer data structure from a file descriptor. The name of the type is used to construct the name of the routine, which has the two parts type and Read.
 cxUnknown* cxUnknownRead( FILE *fd );
 integer function cxUnknownRead( fd )
fd
The fd argument is the file descriptor from which to read data. In C, fd is of type FILE*. In Fortran, its type is integer.
Routines in this group use the IRIS Explorer transcription mechanism to write an ASCII or binary IRIS Explorer data structure to a file descriptor. The name of the type is used to construct the name of the routine, which has the two parts type and Write. The IRIS Explorer ASCII transcription format is not documented (to preserve the option of change at a future date), but is a straightforward ASCII presentation of the input structure; a careful comparison of such an output file with the input dataset will elucidate the format.
 void cxUnknownWrite( FILE *fd, int mode, cxUnknown *src );
 subroutine cxUnknownWrite( fd, mode, src )
fd
The fd argument is the file descriptor to which to write data. In C, fd is of type FILE*. In Fortran, its type is integer.
mode
The integer mode argument determines whether the output file is transcribed in ASCII (mode == 0) or binary (mode != 0) IRIS Explorer format.
This is the cxUnknown data structure definition as specified in the file cxUnknown.t.
shared root typedef struct {
    long            count     "Count";
    char            data[count]     "Data";
} cxUnknown;
cxDataRefInc(3E), cxDataRefDec(3E), cxDataMalloc(3E), cxDataObjNew(3E), cxmkmf(1E)
Last modified: Mon Nov 6 16:33:51 GMT 2000
[ Documentation Home ]
© The Numerical Algorithms Group Ltd, Oxford UK. 1999