845 lines
27 KiB
C
845 lines
27 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Copyright 1993, University Corporation for Atmospheric Research *
|
|
* See netcdf/COPYRIGHT file for copying and redistribution conditions. *
|
|
* *
|
|
* Copyright by The HDF Group. *
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
* All rights reserved. *
|
|
* *
|
|
* This file is part of HDF. The full HDF copyright notice, including *
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
* the COPYING file, which can be found at the root of the source code *
|
|
* distribution tree, or in https://support.hdfgroup.org/ftp/HDF/releases/. *
|
|
* If you do not have access to either file, you may request a copy from *
|
|
* help@hdfgroup.org. *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
/* $Id$ */
|
|
#ifndef _LOCAL_NC_
|
|
#define _LOCAL_NC_
|
|
|
|
#include "H4api_adpt.h"
|
|
/*
|
|
* netcdf library 'private' data structures, objects and interfaces
|
|
*/
|
|
|
|
#include <stddef.h> /* size_t */
|
|
#include <stdio.h> /* FILENAME_MAX */
|
|
|
|
#ifndef FILENAME_MAX
|
|
#define FILENAME_MAX 255
|
|
#endif
|
|
|
|
/* Do we have system XDR files */
|
|
#ifndef H4_NO_SYS_XDR_INC
|
|
|
|
#ifdef __CYGWIN__
|
|
#ifndef __u_char_defined
|
|
typedef unsigned char u_char;
|
|
#define __u_char_defined
|
|
#endif
|
|
#ifndef __u_short_defined
|
|
typedef unsigned short u_short;
|
|
#define __u_short_defined
|
|
#endif
|
|
#ifndef __u_int_defined
|
|
typedef unsigned int u_int;
|
|
#define __u_int_defined
|
|
#endif
|
|
#ifndef __u_long_defined
|
|
typedef unsigned long u_long;
|
|
#define __u_long_defined
|
|
#endif
|
|
#endif /* __CYGWIN__ */
|
|
|
|
#include <rpc/types.h>
|
|
#include <rpc/xdr.h>
|
|
#else /* H4_NO_SYS_XDR_INC */
|
|
#include "types.h" /* <types.h */
|
|
#include "xdr.h" /* <xdr.h> */
|
|
#endif /* H4_NO_SYS_XDR_INC */
|
|
|
|
#ifdef H4_HAVE_NETCDF
|
|
#include "netcdf.h" /* needed for defs of nc_type, ncvoid, ... */
|
|
#else
|
|
#include "hdf4_netcdf.h"
|
|
#endif
|
|
|
|
/* Constants for sizes of NC types */
|
|
#define NC_BYTE_SIZE 1
|
|
#define NC_CHAR_SIZE 1
|
|
#define NC_SHORT_SIZE 2
|
|
#define NC_LONG_SIZE 4
|
|
#define NC_FLOAT_SIZE 4
|
|
#define NC_DOUBLE_SIZE 8
|
|
#define NC_UNSPECIFIED_SIZE 0
|
|
|
|
/* ptr argument type in internal functions */
|
|
#define Void char
|
|
|
|
/*
|
|
** Include HDF stuff
|
|
*/
|
|
#ifdef HDF
|
|
|
|
#include "hdf.h"
|
|
#include "vg.h"
|
|
#include "hfile.h"
|
|
#include "mfhdfi.h"
|
|
|
|
#define ATTR_TAG DFTAG_VH
|
|
#define DIM_TAG DFTAG_VG
|
|
#define VAR_TAG DFTAG_VG
|
|
#define DATA_TAG DFTAG_SD
|
|
#define BOGUS_TAG ((uint16) 721)
|
|
|
|
#if 0
|
|
#define ATTRIBUTE "Attr0.0"
|
|
#define VARIABLE "Var0.0"
|
|
#define DIMENSION "Dim0.0"
|
|
#define UDIMENSION "UDim0.0"
|
|
#define DIM_VALS "DimVal0.0"
|
|
#define DIM_VALS01 "DimVal0.1"
|
|
#define CDF "CDF0.0"
|
|
/* DATA is defined in DTM. Change DATA to DATA0 *
|
|
#define DATA "Data0.0"
|
|
*/
|
|
#define DATA0 "Data0.0"
|
|
#define ATTR_FIELD_NAME "VALUES"
|
|
#endif
|
|
|
|
#define DIMVAL_VERSION00 0 /* <dimsize> fake values */
|
|
#define DIMVAL_VERSION01 1 /* 1 elt with value of <dimsize> */
|
|
#define BLOCK_MULT 64 /* multiplier for bytes in linked blocks */
|
|
#define MAX_BLOCK_SIZE 65536 /* maximum size of block in linked blocks */
|
|
#define BLOCK_COUNT 128 /* size of linked block pointer objects */
|
|
|
|
#endif /* HDF */
|
|
|
|
/* from cdflib.h CDF 2.3 */
|
|
#ifndef MAX_VXR_ENTRIES
|
|
#define MAX_VXR_ENTRIES 10
|
|
#endif /* MAX_VXR_ENTRIES */
|
|
|
|
#ifdef HDF
|
|
/* VIX record for CDF variable data storage */
|
|
typedef struct vix_t_def {
|
|
int32 nEntries; /* number of entries in this vix */
|
|
int32 nUsed; /* number of entries containing valid data */
|
|
int32 firstRec[MAX_VXR_ENTRIES]; /* number of first records */
|
|
int32 lastRec[MAX_VXR_ENTRIES]; /* number of last records */
|
|
int32 offset[MAX_VXR_ENTRIES]; /* file offset of records */
|
|
struct vix_t_def * next; /* next one in line */
|
|
} vix_t;
|
|
#endif /* HDF */
|
|
|
|
/* like, a discriminated union in the sense of xdr */
|
|
typedef struct {
|
|
nc_type type ; /* the discriminant */
|
|
size_t len ; /* the total length originally allocated */
|
|
size_t szof ; /* sizeof each value */
|
|
unsigned count ; /* length of the array */
|
|
Void *values ; /* the actual data */
|
|
} NC_array ;
|
|
|
|
/* Counted string for names and such */
|
|
/*
|
|
|
|
count is the actual size of the buffer for the string
|
|
len is the length of the string in the buffer
|
|
|
|
count != len when a string is resized to something smaller
|
|
|
|
*/
|
|
#ifdef HDF
|
|
#define NC_compare_string(s1,s2) ((s1)->hash!=(s2)->hash ? 1 : HDstrcmp((s1)->values,(s2)->values))
|
|
#endif /* HDF */
|
|
|
|
typedef struct {
|
|
unsigned count ;
|
|
unsigned len ;
|
|
#ifdef HDF
|
|
uint32 hash; /* [non-perfect] hash value for faster comparisons */
|
|
#endif /* HDF */
|
|
char *values ;
|
|
} NC_string ;
|
|
|
|
/* Counted array of ints for assoc list */
|
|
typedef struct {
|
|
unsigned count ;
|
|
int *values ;
|
|
} NC_iarray ;
|
|
|
|
/* NC dimension stucture */
|
|
typedef struct {
|
|
NC_string *name ;
|
|
long size ;
|
|
#ifdef HDF
|
|
int32 dim00_compat; /* compatible with Dim0.0 */
|
|
int32 vgid; /* id of the Vgroup representing this dimension */
|
|
int32 count; /* Number of pointers to this dimension */
|
|
#endif
|
|
} NC_dim ;
|
|
|
|
/* NC attribute */
|
|
typedef struct {
|
|
NC_string *name ;
|
|
NC_array *data ;
|
|
#ifdef HDF
|
|
int32 HDFtype; /* it should be in NC_array *data. However, */
|
|
/* NC.dims and NC.vars are NC_array too. */
|
|
#endif
|
|
} NC_attr ;
|
|
|
|
typedef struct {
|
|
char path[FILENAME_MAX + 1] ;
|
|
unsigned flags ;
|
|
XDR *xdrs ;
|
|
long begin_rec ; /* (off_t) postion of the first 'record' */
|
|
unsigned long recsize ; /* length of 'record' */
|
|
int redefid ;
|
|
/* below gets xdr'd */
|
|
unsigned long numrecs ; /* number of 'records' allocated */
|
|
NC_array *dims ;
|
|
NC_array *attrs ;
|
|
NC_array *vars ;
|
|
#ifdef HDF
|
|
int32 hdf_file;
|
|
int file_type;
|
|
int32 vgid;
|
|
int hdf_mode; /* mode we are attached for */
|
|
hdf_file_t cdf_fp; /* file pointer used for CDF files */
|
|
#endif
|
|
} NC ;
|
|
|
|
/* NC variable: description and data */
|
|
typedef struct {
|
|
NC_string *name ; /* name->values shows data set's name */
|
|
NC_iarray *assoc ; /* user definition */
|
|
unsigned long *shape ; /* compiled info (Each holds a dimension size. -BMR) */
|
|
unsigned long *dsizes ; /* compiled info (Each element holds the amount of space
|
|
needed to hold values in that dimension, e.g., first dimension
|
|
size is 10, value type is int32=4, then dsizes[0]=4*10=40. -BMR) */
|
|
NC_array *attrs; /* list of attribute structures */
|
|
nc_type type ; /* the discriminant */
|
|
unsigned long len ; /* the total length originally allocated */
|
|
size_t szof ; /* sizeof each value */
|
|
long begin ; /* seek index, often an off_t */
|
|
#ifdef HDF
|
|
NC *cdf; /* handle of the file where this var belongs to */
|
|
int32 vgid; /* id of the variable's Vgroup */
|
|
uint16 data_ref;/* ref of the variable's data storage (if exists), default 0 */
|
|
uint16 data_tag;/* tag of the variable's data storage (if exists), default DATA_TAG */
|
|
uint16 ndg_ref; /* ref of ndg for this dataset */
|
|
hdf_vartype_t var_type; /* type of this variable, default UNKNOWN
|
|
IS_SDSVAR == this var is an SDS variable
|
|
IS_CRDVAR == this var is a coordinate variable
|
|
UNKNOWN == because the var was created prior to this distinction.
|
|
This is to distinguish b/w a one-dim data set and a coord var of the same name.
|
|
It's less riskier than using a flag and change the file format, I think. -BMR */
|
|
intn data_offset; /* non-traditional data may not begin at 0 */
|
|
int32 block_size; /* size of the blocks for unlimited dim. datasets, default -1 */
|
|
int numrecs; /* number of records this has been filled up to, for unlimited dim */
|
|
int32 aid; /* aid for DFTAG_SD data */
|
|
int32 HDFtype; /* type of this variable as HDF thinks */
|
|
int32 HDFsize; /* size of this variable as HDF thinks */
|
|
/* These next two flags control when space in the file is allocated
|
|
for a new dataset. They are used (currently) in SDwritedata() and
|
|
hdf_get_vp_aid() to allocate the full length of a new fixed-size dataset
|
|
which is not writing fill values, instead of letting them get created
|
|
as an "appendable" dataset and probably get converted into a linked-
|
|
block special element when they don't need to be one */
|
|
int32 created; /* BOOLEAN == is newly created */
|
|
int32 set_length; /* BOOLEAN == needs length set */
|
|
int32 is_ragged; /* BOOLEAN == is a ragged array */
|
|
int32 * rag_list; /* size of ragged array lines */
|
|
int32 rag_fill; /* last line in rag_list to be set */
|
|
vix_t * vixHead; /* list of VXR records for CDF data storage */
|
|
#endif
|
|
} NC_var ;
|
|
|
|
#define IS_RECVAR(vp) \
|
|
((vp)->shape != NULL ? (*(vp)->shape == NC_UNLIMITED) : 0 )
|
|
|
|
#define netCDF_FILE 0
|
|
#define HDF_FILE 1
|
|
#define CDF_FILE 2
|
|
|
|
HDFLIBAPI const char *cdf_routine_name ; /* defined in lerror.c */
|
|
|
|
#define MAGICOFFSET 0 /* Offset where format version number is written */
|
|
|
|
/* Format version number for CDF file */
|
|
/* Written twice at the beginning of pre-2.6 CDF file */
|
|
#define CDFMAGIC 0x0000FFFF
|
|
|
|
/* Format version number for HDF file */
|
|
#define HDFXMAGIC 0x0e031301 /* ^N^C^S^A */
|
|
|
|
/* Format version number for netCDF classic file */
|
|
#define NCMAGIC 0x43444601 /* C D F 1 */
|
|
|
|
/* Format version number for 64-bit offset file */
|
|
#define NCMAGIC64 0x43444602 /* C D F 2 */
|
|
|
|
/* Format version number for link file */
|
|
#define NCLINKMAGIC 0x43444c01 /* C D L 1 */
|
|
|
|
/* #ifndef HDF *//* HDF has already worked out if we have prototypes */
|
|
#ifdef HDF
|
|
#define PROTOTYPE
|
|
#endif
|
|
#undef PROTO
|
|
#ifndef NO_HAVE_PROTOTYPES
|
|
# define PROTO(x) x
|
|
#else
|
|
# define PROTO(x) ()
|
|
#endif
|
|
/* #endif */ /* HDF */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* If using the real netCDF library and API (when --disable-netcdf configure flag is used)
|
|
need to mangle the HDF versions of netCDF API function names
|
|
to not conflict w/ oriinal netCDF ones */
|
|
#ifndef H4_HAVE_NETCDF
|
|
#define nc_serror HNAME(nc_serror)
|
|
#define NCadvise HNAME(NCadvise)
|
|
#define NC_computeshapes HNAME(NC_computeshapes)
|
|
#define NC_xtypelen HNAME(NC_xtypelen)
|
|
#define NC_xlen_array HNAME(NC_xlen_array)
|
|
#define NC_xlen_attr HNAME(NC_xlen_attr)
|
|
#define NC_xlen_cdf HNAME(NC_xlen_cdf)
|
|
#define NC_xlen_dim HNAME(NC_xlen_dim)
|
|
#define NC_xlen_iarray HNAME(NC_xlen_iarray)
|
|
#define NC_xlen_string HNAME(NC_xlen_string)
|
|
#define NC_xlen_var HNAME(NC_xlen_var)
|
|
#define NCmemset HNAME(NCmemset)
|
|
#define NC_arrayfill HNAME(NC_arrayfill)
|
|
#define NC_copy_arrayvals HNAME(NC_copy_arrayvals)
|
|
#define NC_free_array HNAME(NC_free_array)
|
|
#define NC_free_attr HNAME(NC_free_attr)
|
|
#define NC_free_cdf HNAME(NC_free_cdf)
|
|
#define NC_free_dim HNAME(NC_free_dim)
|
|
#define NC_free_iarray HNAME(NC_free_iarray)
|
|
#define NC_free_string HNAME(NC_free_string)
|
|
#define NC_free_var HNAME(NC_free_var)
|
|
#define NC_incr_array HNAME(NC_incr_array)
|
|
#define NC_dimid HNAME(NC_dimid)
|
|
#define NCcktype HNAME(NCcktype)
|
|
#define NC_indefine HNAME(NC_indefine)
|
|
#define xdr_cdf HNAME(xdr_cdf)
|
|
#define xdr_numrecs HNAME(xdr_numrecs)
|
|
#define xdr_shorts HNAME(xdr_shorts)
|
|
#define xdr_NC_array HNAME(xdr_NC_array)
|
|
#define xdr_NC_attr HNAME(xdr_NC_attr)
|
|
#define xdr_NC_dim HNAME(xdr_NC_dim)
|
|
#define xdr_NC_fill HNAME(xdr_NC_fill)
|
|
#define xdr_NC_iarray HNAME(xdr_NC_iarray)
|
|
#define xdr_NC_string HNAME(xdr_NC_string)
|
|
#define xdr_NC_var HNAME(xdr_NC_var)
|
|
#define NC_typelen HNAME(NC_typelen)
|
|
#define NC_check_id HNAME(NC_check_id)
|
|
#define NC_dup_cdf HNAME(NC_dup_cdf)
|
|
#define NC_new_cdf HNAME(NC_new_cdf)
|
|
#define NC_new_array HNAME(NC_new_array)
|
|
#define NC_re_array HNAME(NC_re_array)
|
|
#define NC_new_attr HNAME(NC_new_attr)
|
|
#define NC_findattr HNAME(NC_findattr)
|
|
#define NC_new_dim HNAME(NC_new_dim)
|
|
#define NC_new_iarray HNAME(NC_new_iarray)
|
|
#define NC_new_string HNAME(NC_new_string)
|
|
#define NC_re_string HNAME(NC_re_string)
|
|
#define NC_hlookupvar HNAME(NC_hlookupvar)
|
|
#define NC_new_var HNAME(NC_new_var)
|
|
#define NCvario HNAME(NCvario)
|
|
#define NCcoordck HNAME(NCcoordck)
|
|
#define xdr_NCvshort HNAME(xdr_NCvshort)
|
|
#define NC_dcpy HNAME(NC_dcpy)
|
|
#define NCxdrfile_sync HNAME(NCxdrfile_sync)
|
|
#define NCxdrfile_create HNAME(NCxdrfile_create)
|
|
#ifdef HDF
|
|
#define NCgenio HNAME(NCgenio) /* from putgetg.c */
|
|
#define NC_var_shape HNAME(NC_var_shape) /* from var.c */
|
|
#endif
|
|
#endif /* !H4_HAVE_NETCDF ie. NOT USING HDF version of netCDF ncxxx API */
|
|
|
|
#define nncpopt H4_F77_FUNC(ncpopt, NCPOPT)
|
|
#define nncgopt H4_F77_FUNC(ncgopt, NCGOPT)
|
|
#define nnccre H4_F77_FUNC(nccre, NCCRE)
|
|
#define nncopn H4_F77_FUNC(ncopn, NCOPN)
|
|
#define nncddef H4_F77_FUNC(ncddef, NCDDEF)
|
|
#define nncdid H4_F77_FUNC(ncdid, NCDID)
|
|
#define nncvdef H4_F77_FUNC(ncvdef, NCVDEF)
|
|
#define nncvid H4_F77_FUNC(ncvid, NCVID)
|
|
#define nnctlen H4_F77_FUNC(nctlen, NCTLEN)
|
|
#define nncclos H4_F77_FUNC(ncclos, NCCLOS)
|
|
#define nncredf H4_F77_FUNC(ncredf, NCREDF)
|
|
#define nncendf H4_F77_FUNC(ncendf, NCENDF)
|
|
#define nncinq H4_F77_FUNC(ncinq, NCINQ)
|
|
#define nncsnc H4_F77_FUNC(ncsnc, NCSNC)
|
|
#define nncabor H4_F77_FUNC(ncabor, NCABOR)
|
|
#define nncdinq H4_F77_FUNC(ncdinq, NCDINQ)
|
|
#define nncdren H4_F77_FUNC(ncdren, NCDREN)
|
|
#define nncvinq H4_F77_FUNC(ncvinq, NCVINQ)
|
|
#define nncvpt1 H4_F77_FUNC(ncvpt1, NCVPT1)
|
|
#define nncvp1c H4_F77_FUNC(ncvp1c, NCVP1C)
|
|
#define nncvpt H4_F77_FUNC(ncvpt, NCVPT)
|
|
#define nncvptc H4_F77_FUNC(ncvptc, NCVPTC)
|
|
#define nncvptg H4_F77_FUNC(ncvptg, NCVPTG)
|
|
#define nncvpgc H4_F77_FUNC(ncvpgc, NCVPGC)
|
|
#define nncvgt1 H4_F77_FUNC(ncvgt1, NCVGT1)
|
|
#define nncvg1c H4_F77_FUNC(ncvg1c, NCVG1C)
|
|
#define nncvgt H4_F77_FUNC(ncvgt, NCVGT)
|
|
#define nncvgtc H4_F77_FUNC(ncvgtc, NCVGTC)
|
|
#define nncvgtg H4_F77_FUNC(ncvgtg, NCVGTG)
|
|
#define nncvggc H4_F77_FUNC(ncvggc, NCVGGC)
|
|
#define nncvren H4_F77_FUNC(ncvren, NCVREN)
|
|
#define nncapt H4_F77_FUNC(ncapt, NCAPT)
|
|
#define nncaptc H4_F77_FUNC(ncaptc, NCAPTC)
|
|
#define nncainq H4_F77_FUNC(ncainq, NCAINQ)
|
|
#define nncagt H4_F77_FUNC(ncagt, NCAGT)
|
|
#define nncagtc H4_F77_FUNC(ncagtc, NCAGTC)
|
|
#define nncacpy H4_F77_FUNC(ncacpy, NCACPY)
|
|
#define nncanam H4_F77_FUNC(ncanam, NCANAM)
|
|
#define nncaren H4_F77_FUNC(ncaren, NCAREN)
|
|
#define nncadel H4_F77_FUNC(ncadel, NCADEL)
|
|
#define nncsfil H4_F77_FUNC(ncsfil, NCSFIL)
|
|
|
|
#ifdef WIN32
|
|
HDFFCLIBAPI void nncpopt
|
|
PROTO((int* val));
|
|
HDFFCLIBAPI void nncgopt
|
|
PROTO((int* val));
|
|
HDFFCLIBAPI int nnccre
|
|
PROTO((char* pathname, int* clobmode, int* rcode, int pathnamelen));
|
|
HDFFCLIBAPI int nncopn
|
|
PROTO((char* pathname, int* rwmode, int* rcode, int pathnamelen));
|
|
HDFFCLIBAPI int nncddef
|
|
PROTO((int* cdfid, char* dimname, int* dimlen, int* rcode, int dimnamelen));
|
|
HDFFCLIBAPI int nncdid
|
|
PROTO((int* cdfid, char* dimname, int* rcode, int dimnamelen));
|
|
HDFFCLIBAPI int nncvdef
|
|
PROTO((int* cdfid, char* varname, int* datatype, int* ndims, int* dimarray, int* rcode, int varnamelen));
|
|
HDFFCLIBAPI int nncvid
|
|
PROTO((int* cdfid, char* varname, int* rcode, int varnamelen));
|
|
HDFFCLIBAPI int nnctlen
|
|
PROTO((int* datatype, int* rcode));
|
|
HDFFCLIBAPI void nncclos
|
|
PROTO((int* cdfid, int* rcode));
|
|
HDFFCLIBAPI void nncredf
|
|
PROTO((int* cdfid, int* rcode));
|
|
HDFFCLIBAPI void nncendf
|
|
PROTO((int* cdfid, int* rcode));
|
|
HDFFCLIBAPI void nncinq
|
|
PROTO((int* cdfid, int* ndims, int* nvars, int* natts, int* recdim, int* rcode));
|
|
HDFFCLIBAPI void nncsnc
|
|
PROTO((int* cdfid, int* rcode));
|
|
HDFFCLIBAPI void nncabor
|
|
PROTO((int* cdfid, int* rcode));
|
|
HDFFCLIBAPI void nncdinq
|
|
PROTO((int* cdfid, int* dimid, char* dimname, int* size, int* rcode, int dimnamelen));
|
|
HDFFCLIBAPI void nncdren
|
|
PROTO((int* cdfid, int* dimid, char* dimname, int* rcode, int dimnamelen));
|
|
HDFFCLIBAPI void nncvinq
|
|
PROTO((int* cdfid, int* varid, char* varname, int* datatype, int* ndims, int* dimarray, int* natts, int* rcode, int varnamelen));
|
|
HDFFCLIBAPI void nncvpt1
|
|
PROTO((int* cdfid, int* varid, int* indices, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvp1c
|
|
PROTO((int* cdfid, int* varid, int* indices, char* chval, int* rcode, int chvallen));
|
|
HDFFCLIBAPI void nncvpt
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvptc
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, char* string, int* lenstr, int* rcode, int stringlen));
|
|
HDFFCLIBAPI void nncvptg
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, int* stride, int* basis, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvpgc
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, int* stride, int* basis, char* string, int* rcode, int stringlen));
|
|
HDFFCLIBAPI void nncvgt1
|
|
PROTO((int* cdfid, int* varid, int* indices, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvg1c
|
|
PROTO((int* cdfid, int* varid, int* indices, char* chval, int* rcode, int chvallen));
|
|
HDFFCLIBAPI void nncvgt
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvgtc
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, char* string, int* lenstr, int* rcode, int stringlen));
|
|
HDFFCLIBAPI void nncvgtg
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, int* stride, int* basis, void* value, int* rcode));
|
|
HDFFCLIBAPI void nncvggc
|
|
PROTO((int* cdfid, int* varid, int* start, int* count, int* stride, int* basis, char* string, int* rcode, int stringlen));
|
|
HDFFCLIBAPI void nncvren
|
|
PROTO((int* cdfid, int* varid, char* varname, int* rcode, int varnamelen));
|
|
HDFFCLIBAPI void nncapt
|
|
PROTO((int* cdfid, int* varid, char* attname, int* datatype, int* attlen, void* value, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI void nncaptc
|
|
PROTO((int* cdfid, int* varid, char* attname, int* datatype, int* lenstr, char* string, int* rcode, int attnamelen, int stringlen));
|
|
HDFFCLIBAPI void nncainq
|
|
PROTO((int* cdfid, int* varid, char* attname, int* datatype, int* attlen, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI void nncagt
|
|
PROTO((int* cdfid, int* varid, char* attname, void* value, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI void nncagtc
|
|
PROTO((int* cdfid, int* varid, char* attname, char* string, int* lenstr, int* rcode, int attnamelen, int stringlen));
|
|
HDFFCLIBAPI void nncacpy
|
|
PROTO((int* incdfid, int* invarid, char* attname, int* outcdfid, int* outvarid, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI void nncanam
|
|
PROTO((int* cdfid, int* varid, int* attnum, char* attname, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI void nncaren
|
|
PROTO((int* cdfid, int* varid, char* attname, char* newname, int* rcode, int attnamelen, int newnamelen));
|
|
HDFFCLIBAPI void nncadel
|
|
PROTO((int* cdfid, int* varid, char* attname, int* rcode, int attnamelen));
|
|
HDFFCLIBAPI int nncsfil
|
|
PROTO((int* cdfid, int* fillmode, int* rcode));
|
|
#endif
|
|
|
|
HDFLIBAPI void nc_serror PROTO((
|
|
const char *fmt,
|
|
...
|
|
)) ;
|
|
HDFLIBAPI void NCadvise PROTO((
|
|
int err,
|
|
const char *fmt,
|
|
...
|
|
)) ;
|
|
|
|
HDFLIBAPI int NC_computeshapes PROTO((
|
|
NC *handle
|
|
));
|
|
HDFLIBAPI int NC_xtypelen PROTO((
|
|
nc_type type
|
|
));
|
|
HDFLIBAPI int NC_xlen_array PROTO((
|
|
NC_array *array
|
|
));
|
|
HDFLIBAPI int NC_xlen_attr PROTO((
|
|
NC_attr **app
|
|
));
|
|
HDFLIBAPI int NC_xlen_cdf PROTO((
|
|
NC *cdf
|
|
));
|
|
HDFLIBAPI int NC_xlen_dim PROTO((
|
|
NC_dim **dpp
|
|
));
|
|
HDFLIBAPI int NC_xlen_iarray PROTO((
|
|
NC_iarray *iarray
|
|
));
|
|
HDFLIBAPI int NC_xlen_string PROTO((
|
|
NC_string *cdfstr
|
|
));
|
|
HDFLIBAPI int NC_xlen_var PROTO((
|
|
NC_var **vpp
|
|
));
|
|
|
|
HDFLIBAPI char *NCmemset PROTO((
|
|
char *s,
|
|
int c,
|
|
int n
|
|
));
|
|
|
|
HDFLIBAPI void NC_arrayfill PROTO((
|
|
void *lo,
|
|
size_t len,
|
|
nc_type type
|
|
));
|
|
HDFLIBAPI void NC_copy_arrayvals PROTO((
|
|
char *target,
|
|
NC_array *array
|
|
));
|
|
HDFLIBAPI int NC_free_array PROTO((
|
|
NC_array *array
|
|
));
|
|
HDFLIBAPI int NC_free_attr PROTO((
|
|
NC_attr *attr
|
|
));
|
|
HDFLIBAPI int NC_free_cdf PROTO((
|
|
NC *handle
|
|
));
|
|
HDFLIBAPI int NC_free_dim PROTO((
|
|
NC_dim *dim
|
|
));
|
|
HDFLIBAPI int NC_free_iarray PROTO((
|
|
NC_iarray *iarray
|
|
));
|
|
HDFLIBAPI int NC_free_string PROTO((
|
|
NC_string *cdfstr
|
|
));
|
|
HDFLIBAPI int NC_free_var PROTO((
|
|
NC_var *var
|
|
));
|
|
|
|
HDFLIBAPI Void *NC_incr_array PROTO((
|
|
NC_array *array,
|
|
Void *tail
|
|
));
|
|
|
|
HDFLIBAPI int NC_dimid PROTO((
|
|
NC *handle,
|
|
char *name
|
|
));
|
|
HDFLIBAPI bool_t NCcktype PROTO((
|
|
nc_type datatype
|
|
));
|
|
HDFLIBAPI bool_t NC_indefine PROTO((
|
|
int cdfid,
|
|
bool_t iserr
|
|
));
|
|
HDFLIBAPI bool_t xdr_cdf PROTO((
|
|
XDR *xdrs,
|
|
NC **handlep
|
|
));
|
|
HDFLIBAPI bool_t xdr_numrecs PROTO((
|
|
XDR *xdrs,
|
|
NC *handle
|
|
));
|
|
HDFLIBAPI bool_t xdr_shorts PROTO((
|
|
XDR *xdrs,
|
|
short *sp,
|
|
u_int cnt
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_array PROTO((
|
|
XDR *xdrs,
|
|
NC_array **app
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_attr PROTO((
|
|
XDR *xdrs,
|
|
NC_attr **app
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_dim PROTO((
|
|
XDR *xdrs,
|
|
NC_dim **dpp
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_fill PROTO((
|
|
XDR *xdrs,
|
|
NC_var *vp
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_iarray PROTO((
|
|
XDR *xdrs,
|
|
NC_iarray **ipp
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_string PROTO((
|
|
XDR *xdrs,
|
|
NC_string **spp
|
|
));
|
|
HDFLIBAPI bool_t xdr_NC_var PROTO((
|
|
XDR *xdrs,
|
|
NC_var **vpp
|
|
));
|
|
|
|
HDFLIBAPI size_t NC_typelen PROTO((
|
|
nc_type type
|
|
));
|
|
|
|
HDFLIBAPI NC *NC_check_id PROTO((
|
|
int cdfid
|
|
));
|
|
HDFLIBAPI NC *NC_dup_cdf PROTO((
|
|
const char *name,
|
|
int mode,
|
|
NC *old
|
|
));
|
|
HDFLIBAPI NC *NC_new_cdf PROTO((
|
|
const char *name,
|
|
int mode
|
|
));
|
|
HDFLIBAPI NC_array *NC_new_array PROTO((
|
|
nc_type type,
|
|
unsigned count,
|
|
const void *values
|
|
));
|
|
HDFLIBAPI NC_array *NC_re_array PROTO((
|
|
NC_array *old,
|
|
nc_type type,
|
|
unsigned count,
|
|
const void *values
|
|
));
|
|
HDFLIBAPI NC_attr *NC_new_attr PROTO((
|
|
const char *name,
|
|
nc_type type,
|
|
unsigned count ,
|
|
const void *values
|
|
));
|
|
HDFLIBAPI NC_attr **NC_findattr PROTO((
|
|
NC_array **ap,
|
|
const char *name
|
|
));
|
|
HDFLIBAPI NC_dim *NC_new_dim PROTO((
|
|
const char *name,
|
|
long size
|
|
));
|
|
HDFLIBAPI NC_iarray *NC_new_iarray PROTO((
|
|
unsigned count,
|
|
const int values[]
|
|
));
|
|
HDFLIBAPI NC_string *NC_new_string PROTO((
|
|
unsigned count,
|
|
const char *str
|
|
));
|
|
HDFLIBAPI NC_string *NC_re_string PROTO((
|
|
NC_string *old,
|
|
unsigned count,
|
|
const char *str
|
|
));
|
|
HDFLIBAPI NC_var *NC_hlookupvar PROTO((
|
|
NC *handle,
|
|
int varid
|
|
));
|
|
HDFLIBAPI NC_var *NC_new_var PROTO((
|
|
const char *name,
|
|
nc_type type,
|
|
int ndims,
|
|
const int *dims
|
|
));
|
|
HDFLIBAPI int NCvario PROTO((
|
|
NC *handle,
|
|
int varid,
|
|
const long *start,
|
|
const long *edges,
|
|
void *values
|
|
));
|
|
HDFLIBAPI bool_t NCcoordck PROTO((
|
|
NC *handle,
|
|
NC_var *vp,
|
|
const long *coords
|
|
));
|
|
HDFLIBAPI bool_t xdr_NCvshort PROTO((
|
|
XDR *xdrs,
|
|
unsigned which,
|
|
short *values
|
|
));
|
|
HDFLIBAPI bool_t NC_dcpy PROTO((
|
|
XDR *target,
|
|
XDR *source,
|
|
long nbytes
|
|
));
|
|
HDFLIBAPI int NCxdrfile_sync
|
|
PROTO((XDR *xdrs));
|
|
|
|
HDFLIBAPI int NCxdrfile_create
|
|
PROTO((XDR *xdrs,const char *path,int ncmode));
|
|
|
|
#ifdef HDF
|
|
/* this routine is found in 'xdrposix.c' */
|
|
HDFLIBAPI void hdf_xdrfile_create
|
|
PROTO(( XDR *xdrs, int ncop));
|
|
|
|
HDFLIBAPI intn hdf_fill_array
|
|
PROTO((Void * storage,int32 len,Void * value,int32 type));
|
|
|
|
HDFLIBAPI intn hdf_get_data
|
|
PROTO((NC *handle,NC_var *vp));
|
|
|
|
HDFLIBAPI int32 hdf_get_vp_aid
|
|
PROTO((NC *handle, NC_var *vp));
|
|
|
|
HDFLIBAPI int hdf_map_type
|
|
PROTO((nc_type ));
|
|
|
|
HDFLIBAPI nc_type hdf_unmap_type
|
|
PROTO((int ));
|
|
|
|
HDFLIBAPI intn hdf_get_ref
|
|
PROTO((NC *,int ));
|
|
|
|
HDFLIBAPI intn hdf_create_dim_vdata
|
|
PROTO((XDR *,NC *,NC_dim *));
|
|
|
|
HDFLIBAPI intn hdf_create_compat_dim_vdata
|
|
PROTO((XDR *xdrs, NC *handle, NC_dim *dim, int32 dimval_ver));
|
|
|
|
HDFLIBAPI intn hdf_write_attr
|
|
PROTO((XDR *,NC *,NC_attr **));
|
|
|
|
HDFLIBAPI int32 hdf_write_dim
|
|
PROTO((XDR *,NC *,NC_dim **,int32));
|
|
|
|
HDFLIBAPI int32 hdf_write_var
|
|
PROTO((XDR *,NC *,NC_var **));
|
|
|
|
HDFLIBAPI intn hdf_write_xdr_cdf
|
|
PROTO((XDR *,NC **));
|
|
|
|
HDFLIBAPI intn hdf_conv_scales
|
|
PROTO((NC **));
|
|
|
|
HDFLIBAPI intn hdf_read_dims
|
|
PROTO((XDR *,NC *,int32 ));
|
|
|
|
HDFLIBAPI NC_array *hdf_read_attrs
|
|
PROTO((XDR *,NC *,int32 ));
|
|
|
|
HDFLIBAPI intn hdf_read_vars
|
|
PROTO((XDR *,NC *,int32 ));
|
|
|
|
HDFLIBAPI intn hdf_read_xdr_cdf
|
|
PROTO((XDR *,NC **));
|
|
|
|
HDFLIBAPI intn hdf_xdr_cdf
|
|
PROTO((XDR *,NC **));
|
|
|
|
HDFLIBAPI intn hdf_vg_clobber
|
|
PROTO((NC *,int ));
|
|
|
|
HDFLIBAPI intn hdf_cdf_clobber
|
|
PROTO((NC *));
|
|
|
|
HDFLIBAPI intn hdf_close
|
|
PROTO((NC *));
|
|
|
|
HDFLIBAPI intn hdf_read_sds_dims
|
|
PROTO((NC *));
|
|
|
|
HDFLIBAPI intn hdf_read_sds_cdf
|
|
PROTO((XDR *,NC **));
|
|
|
|
HDFLIBAPI intn SDPfreebuf PROTO((void));
|
|
|
|
HDFLIBAPI intn NCgenio
|
|
PROTO((NC *handle, int varid, const long *start, const long *count,
|
|
const long *stride, const long *imap, void *values));
|
|
|
|
HDFLIBAPI intn NC_var_shape
|
|
PROTO((NC_var *var,NC_array *dims));
|
|
|
|
HDFLIBAPI intn NC_reset_maxopenfiles
|
|
PROTO((intn req_max));
|
|
|
|
HDFLIBAPI intn NC_get_maxopenfiles
|
|
PROTO(());
|
|
|
|
HDFLIBAPI intn NC_get_systemlimit
|
|
PROTO(());
|
|
|
|
HDFLIBAPI int NC_get_numopencdfs
|
|
PROTO(());
|
|
|
|
/* CDF stuff. don't need anymore? -GV */
|
|
HDFLIBAPI nc_type cdf_unmap_type
|
|
PROTO((int type));
|
|
|
|
HDFLIBAPI bool_t nssdc_read_cdf
|
|
PROTO((XDR *xdrs, NC **handlep));
|
|
|
|
HDFLIBAPI bool_t nssdc_write_cdf
|
|
PROTO((XDR *xdrs, NC **handlep));
|
|
|
|
HDFLIBAPI bool_t nssdc_xdr_cdf
|
|
PROTO((XDR *xdrs, NC **handlep));
|
|
|
|
HDFLIBAPI intn HDiscdf
|
|
(const char *filename);
|
|
|
|
HDFLIBAPI intn HDisnetcdf
|
|
(const char *filename);
|
|
|
|
HDFLIBAPI intn HDisnetcdf64
|
|
(const char *filename);
|
|
|
|
#endif /* HDF */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _LOCAL_NC_ */
|