NAME

cxGenericAlloc, cxGenericCopy, cxGenericDup, cxGenericRead, cxGenericWrite, cxGenericdataGet, cxGenericdataLen, cxGenericdataRem, cxGenericdataSet, cxGenericlenGet, cxGenericlenSet, cxGenericnameGet, cxGenericnameRem, cxGenericnameSet, defined(WIN32) - interface routines for IRIS Explorer cxGeneric data structure #include <cx/cxGeneric.api.h>
  #ifndef __cxGeneric_API_H_ #define __cxGeneric_API_H_ #ifdef __cplusplus "C" { #endif  #include <stdio.h> #if defined(__sun) || defined(WIN32)
 cxGeneric* cxGenericAlloc( signed int len );
 cxGeneric* cxGenericCopy( cxGeneric *src );
 cxGeneric* cxGenericDup( cxGeneric *src );
 cxGeneric* cxGenericRead( FILE *fd );
 void cxGenericWrite( FILE *fd, int mode, cxGeneric *src );
 unsigned char* cxGenericdataGet( cxGeneric *src, cxErrorCode *ec );
 long cxGenericdataLen( cxGeneric *src, cxErrorCode *ec );
 void cxGenericdataRem( cxGeneric *src, unsigned char* *val, cxErrorCode *ec );
 void cxGenericdataSet( cxGeneric *src, unsigned char* val, cxErrorCode *ec );
 signed int cxGenericlenGet( cxGeneric *src, cxErrorCode *ec );
 void cxGenericlenSet( cxGeneric *src, signed int val, cxErrorCode *ec );
 char * cxGenericnameGet( cxGeneric *src, cxErrorCode *ec );
 void cxGenericnameRem( cxGeneric *src, char * *val, cxErrorCode *ec );
 void cxGenericnameSet( cxGeneric *src, char * val, cxErrorCode *ec );
  #ifndef __cxGeneric_API_H_ #define __cxGeneric_API_H_ #ifdef __cplusplus "C" { #endif  #include <stdio.h> #if defined(__sun) || defined(WIN32)
 integer function cxGenericAlloc( len )
 integer function cxGenericCopy( src )
 integer function cxGenericDup( src )
 integer function cxGenericRead( fd )
 subroutine cxGenericWrite( fd, mode, src )
 integer function cxGenericdataGet( src, ec )
 integer function cxGenericdataLen( src, ec )
 subroutine cxGenericdataRem( src, val, ec )
 subroutine cxGenericdataSet( src, val, ec )
 integer function cxGenericlenGet( src, ec )
 subroutine cxGenericlenSet( src, val, ec )
 subroutine  cxGenericnameGet( src, ec , retval)
 subroutine cxGenericnameRem( src, val, ec )
 subroutine cxGenericnameSet( src, val, ec )
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 cxGeneric IRIS Explorer data structure is used to communicate data between modules in the IRIS Explorer scientific visualization system. The cxGeneric 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 cxGeneric structure members. The name of each routine is derived from the label of the associated member in the cxGeneric 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 cxGeneric 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 cxGeneric structure. Not all types of routines may be represented if cxGeneric 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 cxGeneric 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 cxGeneric routines, their discussions also pertain to similar routines for reference-counted types within cxGeneric. While most routines for the cxGeneric 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 cxGeneric.t file exists, you would take the following steps:

        echo cxGeneric > TYPES
        cxmkmf
        make
Now your automatically generated code will reside in cxGeneric.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.
 unsigned char* cxGenericdataGet( cxGeneric *src, cxErrorCode *ec );
 signed int cxGenericlenGet( cxGeneric *src, cxErrorCode *ec );
 char * cxGenericnameGet( cxGeneric *src, cxErrorCode *ec );
 integer function cxGenericdataGet( src, ec )
 integer function cxGenericlenGet( src, ec )
 subroutine  cxGenericnameGet( src, ec , retval)
<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 cxGeneric.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 cxGeneric 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 cxGenericdataSet( cxGeneric *src, unsigned char* val, cxErrorCode *ec );
 void cxGenericlenSet( cxGeneric *src, signed int val, cxErrorCode *ec );
 void cxGenericnameSet( cxGeneric *src, char * val, cxErrorCode *ec );
 subroutine cxGenericdataSet( src, val, ec )
 subroutine cxGenericlenSet( src, val, ec )
 subroutine cxGenericnameSet( 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 cxGeneric.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 cxGeneric 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 cxGenericdataLen( cxGeneric *src, cxErrorCode *ec );
 integer function cxGenericdataLen( 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.
 cxGeneric* cxGenericDup( cxGeneric *src );
 integer function cxGenericDup( 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.
 cxGeneric* cxGenericCopy( cxGeneric *src );
 integer function cxGenericCopy( 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.
 cxGeneric* cxGenericAlloc( signed int len );
 integer function cxGenericAlloc( len )
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 cxGenericdataRem( cxGeneric *src, unsigned char* *val, cxErrorCode *ec );
 void cxGenericnameRem( cxGeneric *src, 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.
 cxGeneric* cxGenericRead( FILE *fd );
 integer function cxGenericRead( 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 cxGenericWrite( FILE *fd, int mode, cxGeneric *src );
 subroutine cxGenericWrite( 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 cxGeneric data structure definition as specified in the file cxGeneric.t.
shared root typedef struct {
    string      name;
    int       len;
    char      data[len];
} cxGeneric;
cxDataRefInc(3E), cxDataRefDec(3E), cxDataMalloc(3E), cxDataObjNew(3E), cxmkmf(1E)
Last modified: Mon Nov 6 16:33:10 GMT 2000
[ Documentation Home ]
© The Numerical Algorithms Group Ltd, Oxford UK. 1999