mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2025-01-24 16:04:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

Delete obsolete libdiskless directory, replaced by new diskless

Browse Source 
implementation.  Deleted obsolete win32, soon to be replaced by Ward's
Windows 32- and 64-bit fixes for building with MSYS/MinGW.  Made
cosmetic cleanup to output of "make check" to make it easier for users
to interpret.  Fixed bug NCF-175: ncdump -t incorrectly interpreting
units attribute (such as "days") without a base time (such as "since
2007-01-01") as a time unit.

Changed name to 4.2.1-beta.
This commit is contained in:
Russ Rew 2012-06-12 21:50:02 +00:00
parent 024f318431
commit 79cde861ac
90 changed files with 122 additions and 12296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile.am
View File

@ -71,8 +71,6 @@ if BUILD_TESTSETS
TESTDIRS = $(V2_TEST) nc_test $(NC_TEST4) $(NCDAPTESTDIR)
endif
WIN32=win32
# This is the list of subdirs for which Makefiles will be constructed
# and run. ncgen must come before ncdump, because their tests
# depend on it.
@ -80,7 +78,7 @@ SUBDIRS = include $(OCLIB) $(H5_TEST_DIR) libdispatch libsrc \
$(LIBSRC4_DIR) $(DAP2) $(LIBCDMR) $(LIBRPC) liblib \
$(NCGEN3) $(NCGEN) $(NCDUMP) \
$(TESTDIRS) \
man4 $(EXAMPLES) $(WIN32)
man4 $(EXAMPLES)
# Remove these generated files, for a distclean.
DISTCLEANFILES = VERSION comps.txt test_prog

42
configure.ac
View File

@ -15,7 +15,7 @@ AC_REVISION([$Id: configure.ac,v 1.450 2010/05/28 19:42:47 dmh Exp $])
AC_PREREQ([2.59])
# Initialize with name, version, and support email address.
AC_INIT([netCDF], [4.2], [support-netcdf@unidata.ucar.edu])
AC_INIT([netCDF], [4.2.1-beta], [support-netcdf@unidata.ucar.edu])
# Create the VERSION file, which contains the package version from
# AC_INIT.
@ -844,28 +844,20 @@ AC_CONFIG_FILES([Makefile
examples/Makefile
examples/C/Makefile
examples/CDL/Makefile
win32/Makefile
win32/NET/Makefile
win32/NET/libsrc/Makefile
win32/NET/ncdump/Makefile
win32/NET/ncgen/Makefile
win32/NET/examples/Makefile
win32/NET/nctest/Makefile
win32/NET/nc_test/Makefile
oc/Makefile
libdap2/Makefile
libcdmr/Makefile
librpc/Makefile
libdispatch/Makefile
liblib/Makefile
ncdump/cdl4/Makefile
ncdump/expected4/Makefile
ncdap_test/Makefile
ncdap_test/testdata3/Makefile
ncdap_test/expected3/Makefile
ncdap_test/expected4/Makefile
ncdap_test/expectremote3/Makefile
ncdap_test/expectremote4/Makefile
],
[test -f nc-config && chmod 755 nc-config])
oc/Makefile
libdap2/Makefile
libcdmr/Makefile
librpc/Makefile
libdispatch/Makefile
liblib/Makefile
ncdump/cdl4/Makefile
ncdump/expected4/Makefile
ncdap_test/Makefile
ncdap_test/testdata3/Makefile
ncdap_test/expected3/Makefile
ncdap_test/expected4/Makefile
ncdap_test/expectremote3/Makefile
ncdap_test/expectremote4/Makefile
],
[test -f nc-config && chmod 755 nc-config])
AC_OUTPUT()

2
include/netcdf.h
View File

@ -120,7 +120,7 @@ extern "C" {
#define NC_CLOBBER 0x0000 /**< Destroy existing file. Mode flag for nc_create(). */
#define NC_NOCLOBBER 0x0004 /**< Don't destroy existing file. Mode flag for nc_create(). */
#define NC_DISKLESS 0x0008 /**< Create a diskless file. Mode flag for nc_create(). */
#define NC_DISKLESS 0x0008 /**< Use diskless file. Mode flag for nc_open() or nc_create(). */
#define NC_CLASSIC_MODEL 0x0100 /**< Enforce classic model. Mode flag for nc_create(). */
#define NC_64BIT_OFFSET 0x0200 /**< Use large (64-bit) file offsets. Mode flag for nc_create(). */

22
libdiskless/Makefile.am
View File

@ -1,22 +0,0 @@
# This is part of Unidata's netCDF package. Copyright 2011, see the
# COPYRIGHT file for more information.
# This automake file generates the Makefile to build the diskless
# library.
include $(top_srcdir)/lib_flags.am
libdiskless_la_CPPFLAGS = ${AM_CPPFLAGS}
# This is our output. The diskless convenience library.
noinst_LTLIBRARIES = libdiskless.la
libdiskless_la_SOURCES = ncddispatch.c ncddispatch.h ncdattr.c \
ncddim.c ncdfile.c ncdgrp.c ncdtype.c ncdvar.c ncdfunc.c error4.c \
ncdinternal.c

75
libdiskless/error4.c
View File

@ -1,75 +0,0 @@
/*
This file is part of netcdf-4, a netCDF-like interface for HDF5, or a
HDF5 backend for netCDF, depending on your point of view.
This file contains functions relating to logging errors. Also it
contains the functions nc_malloc, nc_calloc, and nc_free.
Copyright 2003, University Corporation for Atmospheric Research. See
netcdf-4/docs/COPYRIGHT file for copying and redistribution
conditions.
$Id: error4.c,v 1.4 2010/06/01 17:48:55 ed Exp $
*/
#include <config.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
#include <hdf5.h>
/* This contents of this file get skipped if LOGGING is not defined
* during compile. */
#ifdef LOGGING
extern int nc_log_level;
/* This function prints out a message, if the severity of the message
is lower than the global nc_log_level. To use it, do something like
this:
nc_log(0, "this computer will explode in %d seconds", i);
After the first arg (the severity), use the rest like a normal
printf statement. Output will appear on stdout.
This function is heavily based on the function in section 15.5 of
the C FAQ. */
void
nc_log(int severity, const char *fmt, ...)
{
va_list argp;
int t;
/* If the severity is greater than the log level, we don' care to
print this message. */
if (severity > nc_log_level)
return;
/* If the severity is zero, this is an error. Otherwise insert that
many tabs before the message. */
if (!severity)
fprintf(stdout, "ERROR: ");
for (t=0; t<severity; t++)
fprintf(stdout, "\t");
/* Print out the variable list of args with vprintf. */
va_start(argp, fmt);
vfprintf(stdout, fmt, argp);
va_end(argp);
/* Put on a final linefeed. */
fprintf(stdout, "\n");
fflush(stdout);
}
void
nc_log_hdf5(void)
{
H5Eprint(NULL);
}
#endif /* ifdef LOGGING */

782
libdiskless/ncdattr.c
View File

@ -1,782 +0,0 @@
/** \file \internal
Diskless API attribute functions.
Copyright 2011, University Corporation for Atmospheric Research. See
COPYRIGHT file for copying and redistribution conditions.
*/
#include "nc4internal.h"
#include "nc.h"
#include "ncddispatch.h"
#include "ncdispatch.h"
int nc4typelen(nc_type type);
/* Get or put attribute metadata from our linked list of file
info. Always locate the attribute by name, never by attnum.
The mem_type is ignored if data=NULL. */
int
ncd_get_att(int ncid, NC_FILE_INFO_T *nc, int varid, const char *name,
nc_type *xtype, nc_type mem_type, size_t *lenp,
int *attnum, int is_long, void *data)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_ATT_INFO_T *att;
int my_attnum = -1;
int need_to_convert = 0;
int range_error = NC_NOERR;
void *bufr = NULL;
size_t type_size;
char norm_name[NC_MAX_NAME + 1];
int i;
int retval = NC_NOERR;
if (attnum)
my_attnum = *attnum;
assert(nc && nc->nc4_info);
LOG((3, "ncd_get_att: ncid 0x%x varid %d name %s attnum %d mem_type %d",
ncid, varid, name, my_attnum, mem_type));
/* Find info for this file and group, and set pointer to each. */
h5 = nc->nc4_info;
if (!(grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK))))
return NC_EBADGRPID;
/* Normalize name. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Find the attribute, if it exists. If we don't find it, we are
major failures. */
if ((retval = nc4_find_grp_att(grp, varid, norm_name, my_attnum, &att)))
return retval;
/* If mem_type is NC_NAT, it means we want to use the attribute's
* file type as the mem type as well. */
if (mem_type == NC_NAT)
mem_type = att->xtype;
/* If the attribute is NC_CHAR, and the mem_type isn't, or vice
* versa, that's a freakish attempt to convert text to
* numbers. Some pervert out there is trying to pull a fast one!
* Send him an NC_ECHAR error...*/
if (data && att->len &&
((att->xtype == NC_CHAR && mem_type != NC_CHAR) ||
(att->xtype != NC_CHAR && mem_type == NC_CHAR)))
return NC_ECHAR; /* take that, you freak! */
/* Copy the info. */
if (lenp)
*lenp = att->len;
if (xtype)
*xtype = att->xtype;
if (attnum)
*attnum = att->attnum;
/* Zero len attributes are easy to read! */
if (!att->len)
return NC_NOERR;
/* Later on, we will need to know the size of this type. */
if ((retval = nc4_get_typelen_mem(h5, mem_type, is_long, &type_size)))
return retval;
/* We may have to convert data. Treat NC_CHAR the same as
* NC_UBYTE. If the mem_type is NAT, don't try any conversion - use
* the attribute's type. */
if (data && att->len && mem_type != att->xtype &&
mem_type != NC_NAT &&
!(mem_type == NC_CHAR &&
(att->xtype == NC_UBYTE || att->xtype == NC_BYTE)))
{
need_to_convert++;
if (!(bufr = malloc((size_t)(att->len * type_size))))
return NC_ENOMEM;
if ((retval = nc4_convert_type(att->data, bufr, att->xtype,
mem_type, (size_t)att->len, &range_error,
NULL, (h5->cmode & NC_CLASSIC_MODEL), 0, is_long)))
BAIL(retval);
/* For strict netcdf-3 rules, ignore erange errors between UBYTE
* and BYTE types. */
if ((h5->cmode & NC_CLASSIC_MODEL) &&
(att->xtype == NC_UBYTE || att->xtype == NC_BYTE) &&
(mem_type == NC_UBYTE || mem_type == NC_BYTE) &&
range_error)
range_error = 0;
}
else
{
bufr = att->data;
}
/* If the caller wants data, copy it for him. If he hasn't
allocated enough memory for it, he will burn in segmantation
fault hell, writhing with the agony of undiscovered memory
bugs! */
if (data)
{
if (att->vldata)
{
size_t base_typelen = type_size;
hvl_t *vldest = data;
NC_TYPE_INFO_T *type;
if ((retval = nc4_find_type(h5, att->xtype, &type)))
return retval;
for (i = 0; i < att->len; i++)
{
vldest[i].len = att->vldata[i].len;
if (!(vldest[i].p = malloc(vldest[i].len * base_typelen)))
BAIL(NC_ENOMEM);
memcpy(vldest[i].p, att->vldata[i].p, vldest[i].len * base_typelen);
}
}
else if (att->stdata)
{
for (i = 0; i < att->len; i++)
{
if (!(((char **)data)[i] = malloc(strlen(att->stdata[i]) + 1)))
BAIL(NC_ENOMEM);
strcpy(((char **)data)[i], att->stdata[i]);
}
}
else
{
/* For long types, we need to handle this special... */
if (is_long && att->xtype == NC_INT)
{
long *lp = data;
int *ip = bufr;
for (i = 0; i < att->len; i++)
*lp++ = *ip++;
}
else
memcpy(data, bufr, (size_t)(att->len * type_size));
}
}
exit:
if (need_to_convert) free(bufr);
if (retval)
return retval;
if (range_error)
return NC_ERANGE;
return NC_NOERR;
}
/* Put attribute metadata into our global metadata. */
int
ncd_put_att(int ncid, NC_FILE_INFO_T *nc, int varid, const char *name,
nc_type file_type, nc_type mem_type, size_t len, int is_long,
const void *data)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var = NULL;
NC_ATT_INFO_T *att, **attlist = NULL, *varatt;
NC_TYPE_INFO_T *type = NULL;
char norm_name[NC_MAX_NAME + 1];
int new_att = 0;
int retval = NC_NOERR, range_error = 0;
size_t type_size;
int i;
int res;
if (!name)
return NC_EBADNAME;
assert(nc && nc->nc4_info);
LOG((1, "ncd_put_att: ncid 0x%x varid %d name %s "
"file_type %d mem_type %d len %d", ncid, varid,
name, file_type, mem_type, len));
/* If len is not zero, then there must be some data. */
if (len && !data)
return NC_EINVAL;
/* Find info for this file and group, and set pointer to each. */
h5 = nc->nc4_info;
if (!(grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK))))
return NC_EBADGRPID;
/* If the file is read-only, return an error. */
if (h5->no_write)
return NC_EPERM;
/* Check and normalize the name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* Find att, if it exists. */
if (varid == NC_GLOBAL)
attlist = &grp->att;
else
{
for (var = grp->var; var; var = var->next)
if (var->varid == varid)
{
attlist = &var->att;
break;
}
if (!var)
return NC_ENOTVAR;
}
for (att = *attlist; att; att = att->next)
if (!strcmp(att->name, norm_name))
break;
if (!att)
{
/* If this is a new att, require define mode. */
if (!(h5->flags & NC_INDEF))
{
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_EINDEFINE;
if ((retval = NCD_redef(ncid)))
BAIL(retval);
}
new_att++;
}
else
{
/* For an existing att, if we're not in define mode, the len
must not be greater than the existing len for classic model. */
if (!(h5->flags & NC_INDEF) &&
len * nc4typelen(file_type) > (size_t)att->len * nc4typelen(att->xtype))
{
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_EINDEFINE;
if ((retval = nc_enddef(ncid)))
BAIL(retval);
}
}
/* We must have two valid types to continue. */
if (file_type == NC_NAT || mem_type == NC_NAT)
return NC_EBADTYPE;
/* Get information about this type. */
if ((retval = nc4_find_type(h5, file_type, &type)))
return retval;
if ((retval = nc4_get_typelen_mem(h5, file_type, is_long, &type_size)))
return retval;
/* No character conversions are allowed. */
if (file_type != mem_type &&
(file_type == NC_CHAR || mem_type == NC_CHAR ||
file_type == NC_STRING || mem_type == NC_STRING))
return NC_ECHAR;
/* For classic mode file, only allow atts with classic types to be
* created. */
if (h5->cmode & NC_CLASSIC_MODEL && file_type > NC_DOUBLE)
return NC_ESTRICTNC3;
/* Add to the end of the attribute list, if this att doesn't
already exist. */
if (new_att)
{
LOG((3, "adding attribute %s to the list...", norm_name));
if ((res = nc4_att_list_add(attlist)))
BAIL (res);
/* Find this att's entry in the list (the last one). */
for (att=*attlist; att->next; att=att->next)
;
}
/* Now fill in the metadata. */
att->dirty++;
if (att->name)
free(att->name);
if (!(att->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(att->name, norm_name);
att->xtype = file_type;
att->len = len;
if (att->prev)
att->attnum = att->prev->attnum + 1;
else
att->attnum = 0;
if (type)
att->class = type->class;
/* If this is the _FillValue attribute, then we will also have to
* copy the value to the fll_vlue pointer of the NC_VAR_INFO_T
* struct for this var. (But ignore a global _FillValue
* attribute). */
if (!strcmp(att->name, _FillValue) && varid != NC_GLOBAL)
{
NC_TYPE_INFO_T *type_info;
int size;
/* Fill value must be same type. */
if (att->xtype != var->xtype)
return NC_EINVAL;
/* If we already wrote to the dataset, then return an error. */
if (var->written_to)
return NC_ELATEFILL;
/* If fill value hasn't been set, allocate space. Of course,
* vlens have to be differnt... */
if ((retval = nc4_get_typelen_mem(grp->file->nc4_info, var->xtype, 0,
&type_size)))
return retval;
if ((retval = nc4_find_type(grp->file->nc4_info, var->xtype, &type_info)))
BAIL(retval);
/* Already set a fill value? Now I'll have to free the old
* one. Make up your damn mind, would you? */
if (var->fill_value)
{
if (type_info && type_info->class == NC_VLEN)
if ((retval = nc_free_vlen(var->fill_value)))
return retval;
free(var->fill_value);
}
/* Allocate space for the fill value. */
if (type_info && type_info->class == NC_VLEN)
size = sizeof(hvl_t);
else if (var->xtype == NC_STRING)
size = sizeof(char *);
else
size = type_size;
/* size = strlen(*(char **)data) + 1; */
if (!(var->fill_value = malloc(size)))
return NC_ENOMEM;
/* Copy the fill_value. */
LOG((4, "Copying fill value into metadata for variable %s", var->name));
if (type_info && type_info->class == NC_VLEN)
{
nc_vlen_t *in_vlen = (nc_vlen_t *)data, *fv_vlen = (nc_vlen_t *)(var->fill_value);
fv_vlen->len = in_vlen->len;
if (!(fv_vlen->p = malloc(size * in_vlen->len)))
return NC_ENOMEM;
memcpy(fv_vlen->p, in_vlen->p, in_vlen->len * size);
}
else if (var->xtype == NC_STRING)
{
if (!(*(char **)var->fill_value = malloc(strlen(*(char **)data) + 1)))
return NC_ENOMEM;
strcpy(*(char **)(var->fill_value), *(char **)data);
}
else
memcpy(var->fill_value, data, type_size);
/* Mark the var and all its atts as dirty, so they get
* rewritten. */
var->dirty++;
for (varatt = var->att; varatt; varatt = varatt->next)
varatt->dirty++;
}
/* Copy the attribute data, if there is any. VLENs and string
* arrays have to be handled specially. */
if (type && type->class == NC_VLEN && data && att->len)
{
const hvl_t *vldata1;
vldata1 = data;
if (!(att->vldata = malloc(att->len * sizeof(hvl_t))))
BAIL(NC_ENOMEM);
for (i = 0; i < att->len; i++)
{
att->vldata[i].len = vldata1[i].len;
if (!(att->vldata[i].p = malloc(type_size * att->vldata[i].len)))
BAIL(NC_ENOMEM);
memcpy(att->vldata[i].p, vldata1[i].p, type_size * att->vldata[i].len);
}
}
else if (file_type == NC_STRING && data && att->len)
{
LOG((4, "copying array of NC_STRING"));
if (!(att->stdata = malloc(sizeof(char *) * att->len)))
BAIL(NC_ENOMEM);
for (i = 0; i < att->len; i++)
{
LOG((5, "copying string %d of size %d", i, strlen(((char **)data)[i]) + 1));
if (!(att->stdata[i] = malloc(strlen(((char **)data)[i]) + 1)))
BAIL(NC_ENOMEM);
strcpy(att->stdata[i], ((char **)data)[i]);
}
}
else
{
/* Data types are like religions, in that one can convert. */
if (att->len)
{
if (!new_att)
free (att->data);
if (!(att->data = malloc(att->len * type_size)))
BAIL(NC_ENOMEM);
if (type)
{
/* Just copy the data... */
if (type->class == NC_OPAQUE || type->class == NC_COMPOUND || type->class == NC_ENUM)
memcpy(att->data, data, len * type_size);
else
LOG((0, "ncd_put_att: unknown type."));
}
else
{
if ((retval = nc4_convert_type(data, att->data, mem_type, file_type,
len, &range_error, NULL,
(h5->cmode & NC_CLASSIC_MODEL), is_long, 0)))
BAIL(retval);
}
}
}
att->dirty = 1;
att->created = 0;
exit:
/* If there was an error return it, otherwise return any potential
range error value. If none, return NC_NOERR as usual.*/
if (retval)
return retval;
if (range_error)
return NC_ERANGE;
return NC_NOERR;
}
/* Learn about an att. All the nc4 nc_inq_ functions just call
* add_meta_get to get the metadata on an attribute. */
int
NCD_inq_att(int ncid, int varid, const char *name, nc_type *xtypep, size_t *lenp)
{
NC_FILE_INFO_T *nc;
LOG((2, "nc_inq_att: ncid 0x%x varid %d name %s", ncid, varid, name));
/* Find metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
/* Handle netcdf-4 files. */
return ncd_get_att(ncid, nc, varid, name, xtypep, NC_UBYTE, lenp, NULL, 0, NULL);
}
/* Learn an attnum, given a name. */
int
NCD_inq_attid(int ncid, int varid, const char *name, int *attnump)
{
NC_FILE_INFO_T *nc;
LOG((2, "nc_inq_attid: ncid 0x%x varid %d name %s", ncid, varid, name));
/* Find metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
/* Handle netcdf-4 files. */
return ncd_get_att(ncid, nc, varid, name, NULL, NC_UBYTE,
NULL, attnump, 0, NULL);
}
/* Given an attnum, find the att's name. */
int
NCD_inq_attname(int ncid, int varid, int attnum, char *name)
{
NC_FILE_INFO_T *nc;
NC_ATT_INFO_T *att;
int retval = NC_NOERR;
LOG((2, "nc_inq_attname: ncid 0x%x varid %d attnum %d",
ncid, varid, attnum));
/* Find metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
/* Handle netcdf-4 files. */
if ((retval = nc4_find_nc_att(ncid, varid, NULL, attnum, &att)))
return retval;
/* Get the name. */
if (name)
strcpy(name, att->name);
return NC_NOERR;
}
/* I think all atts should be named the exact same thing, to avoid
confusion! */
int
NCD_rename_att(int ncid, int varid, const char *name,
const char *newname)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
NC_ATT_INFO_T *att, *list;
char norm_newname[NC_MAX_NAME + 1], norm_name[NC_MAX_NAME + 1];
hid_t datasetid = 0;
int retval = NC_NOERR;
if (!name || !newname)
return NC_EINVAL;
LOG((2, "nc_rename_att: ncid 0x%x varid %d name %s newname %s",
ncid, varid, name, newname));
/* If the new name is too long, that's an error. */
if (strlen(newname) > NC_MAX_NAME)
return NC_EMAXNAME;
/* Find metadata for this file. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Handle netcdf-3 files. */
assert(h5);
/* If the file is read-only, return an error. */
if (h5->no_write)
return NC_EPERM;
/* Check and normalize the name. */
if ((retval = nc4_check_name(newname, norm_newname)))
return retval;
/* Is norm_newname in use? */
if (varid == NC_GLOBAL)
{
list = grp->att;
}
else
{
for (var = grp->var; var; var = var->next)
if (var->varid == varid)
{
list = var->att;
break;
}
if (!var)
return NC_ENOTVAR;
}
for (att = list; att; att = att->next)
if (!strncmp(att->name, norm_newname, NC_MAX_NAME))
return NC_ENAMEINUSE;
/* Normalize name and find the attribute. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
for (att = list; att; att = att->next)
if (!strncmp(att->name, norm_name, NC_MAX_NAME))
break;
if (!att)
return NC_ENOTATT;
/* If we're not in define mode, new name must be of equal or
less size, if complying with strict NC3 rules. */
if (!(h5->flags & NC_INDEF) && strlen(norm_newname) > strlen(att->name) &&
(h5->cmode & NC_CLASSIC_MODEL))
return NC_ENOTINDEFINE;
/* Delete the original attribute, if it exists in the HDF5 file. */
if (att->created)
{
if (varid == NC_GLOBAL)
{
if (H5Adelete(grp->hdf_grpid, att->name) < 0)
return NC_EHDFERR;
}
else
{
if ((retval = nc4_open_var_grp2(grp, varid, &datasetid)))
return retval;
if (H5Adelete(datasetid, att->name) < 0)
return NC_EHDFERR;
}
att->created = 0;
}
/* Copy the new name into our metadata. */
free(att->name);
if (!(att->name = malloc((strlen(norm_newname) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(att->name, norm_newname);
att->dirty = 1;
return retval;
}
/* Delete an att. Rub it out. Push the button on it. Liquidate
it. Bump it off. Take it for a one-way ride. Terminate it. Drop the
bomb on it. You get the idea.
Ed Hartnett, 10/1/3
*/
int
NCD_del_att(int ncid, int varid, const char *name)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_ATT_INFO_T *att, *natt;
NC_VAR_INFO_T *var;
NC_ATT_INFO_T **attlist = NULL;
hid_t locid = 0, datasetid = 0;
int retval = NC_NOERR;
if (!name)
return NC_EINVAL;
LOG((2, "nc_del_att: ncid 0x%x varid %d name %s",
ncid, varid, name));
/* Find metadata for this file. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Handle netcdf-3 files. */
assert(h5);
assert(h5 && grp);
/* If the file is read-only, return an error. */
if (h5->no_write)
return NC_EPERM;
/* If it's not in define mode, forget it. */
if (!(h5->flags & NC_INDEF))
{
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_ENOTINDEFINE;
if ((retval = NCD_redef(ncid)))
BAIL(retval);
}
/* Get either the global or a variable attribute list. Also figure
out the HDF5 location it's attached to. */
if (varid == NC_GLOBAL)
{
attlist = &grp->att;
locid = grp->hdf_grpid;
}
else
{
for(var = grp->var; var; var = var->next)
{
if (var->varid == varid)
{
attlist = &var->att;
break;
}
}
if (!var)
return NC_ENOTVAR;
if (var->created)
{
locid = var->hdf_datasetid;
}
}
/* Now find the attribute by name or number. */
for (att = *attlist; att; att = att->next)
if (!strcmp(att->name, name))
break;
/* If att is NULL, we couldn't find the attribute. */
if (!att)
BAIL_QUIET(NC_ENOTATT);
/* Delete it from the HDF5 file, if it's been created. */
if (att->created)
if(H5Adelete(locid, att->name) < 0)
BAIL(NC_EATTMETA);
/* Renumber all following attributes. */
for (natt = att->next; natt; natt = natt->next)
natt->attnum--;
/* Delete this attribute from this list. */
if ((retval = nc4_att_list_del(attlist, att)))
BAIL(retval);
exit:
if (datasetid > 0) H5Dclose(datasetid);
return retval;
}
/* Write an attribute with type conversion. */
int
ncd_put_att_tc(int ncid, int varid, const char *name, nc_type file_type,
nc_type mem_type, int mem_type_is_long, size_t len,
const void *op)
{
NC_FILE_INFO_T *nc;
if (!name || strlen(name) > NC_MAX_NAME)
return NC_EBADNAME;
LOG((3, "ncd_put_att_tc: ncid 0x%x varid %d name %s file_type %d "
"mem_type %d len %d", ncid, varid, name, file_type, mem_type, len));
/* The length needs to be positive (cast needed for braindead
systems with signed size_t). */
if((unsigned long) len > X_INT_MAX)
return NC_EINVAL;
/* Find metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
/* Otherwise, handle things the netcdf-4 way. */
return ncd_put_att(ncid, nc, varid, name, file_type, mem_type, len,
mem_type_is_long, op);
}
/* Read an attribute of any type, with type conversion. This may be
* called by any of the nc_get_att_* functions. */
int
ncd_get_att_tc(int ncid, int varid, const char *name, nc_type mem_type,
int mem_type_is_long, void *ip)
{
NC_FILE_INFO_T *nc;
LOG((3, "ncd_get_att_tc: ncid 0x%x varid %d name %s mem_type %d",
ncid, varid, name, mem_type));
/* Find metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
return ncd_get_att(ncid, nc, varid, name, NULL, mem_type,
NULL, NULL, mem_type_is_long, ip);
}
int
NCD_put_att(int ncid, int varid, const char *name, nc_type xtype,
size_t nelems, const void *value, nc_type memtype)
{
return ncd_put_att_tc(ncid, varid, name, xtype, memtype, 0, nelems, value);
}
int
NCD_get_att(int ncid, int varid, const char *name, void *value, nc_type memtype)
{
return ncd_get_att_tc(ncid, varid, name, memtype, 0, value);
}

355
libdiskless/ncddim.c
View File

@ -1,355 +0,0 @@
/*
This file is part of netcdf-4, a netCDF-like interface for HDF5, or a
HDF5 backend for netCDF, depending on your point of view.
This file handles the nc4 dimension functions.
Copyright 2003-5, University Corporation for Atmospheric Research. See
the COPYRIGHT file for copying and redistribution conditions.
$Id: nc4dim.c,v 1.41 2010/05/25 17:54:23 dmh Exp $
*/
#include "nc4internal.h"
/* Netcdf-4 files might have more than one unlimited dimension, but
return the first one anyway. */
/* Note that this code is inconsistent with nc_inq */
int
NCD_inq_unlimdim(int ncid, int *unlimdimidp)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
NC_DIM_INFO_T *dim;
int found = 0;
int retval;
LOG((2, "called nc_inq_unlimdim"));
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Take care of netcdf-3 files. */
assert(h5);
/* According to netcdf-3 manual, return -1 if there is no unlimited
dimension. */
*unlimdimidp = -1;
for (g = grp; g && !found; g = g->parent)
{
for (dim = g->dim; dim; dim = dim->next)
{
if (dim->unlimited)
{
*unlimdimidp = dim->dimid;
found++;
break;
}
}
}
return NC_NOERR;
}
/* Dimensions are defined in attributes attached to the appropriate
group in the data file. */
int
NCD_def_dim(int ncid, const char *name, size_t len, int *idp)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_DIM_INFO_T *dim;
char norm_name[NC_MAX_NAME + 1];
int retval = NC_NOERR;
LOG((2, "NCD_def_dim: ncid 0x%x name %s len %d", ncid, name,
(int)len));
/* Find our global metadata structure. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
assert(h5 && nc && grp);
/* Check some stuff if strict nc3 rules are in effect. */
if (h5->cmode & NC_CLASSIC_MODEL)
{
/* Only one limited dimenson for strict nc3. */
if (len == NC_UNLIMITED)
for (dim = grp->dim; dim; dim = dim->next)
if (dim->unlimited)
return NC_EUNLIMIT;
/* Must be in define mode for stict nc3. */
if (!(h5->flags & NC_INDEF))
return NC_ENOTINDEFINE;
}
/* If it's not in define mode, enter define mode. */
if (!(h5->flags & NC_INDEF))
if ((retval = nc_redef(ncid)))
return retval;
/* Make sure this is a valid netcdf name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* For classic model, stick with the classic format restriction:
* dim length has to fit in a 32-bit signed int. For 64-bit offset,
* it has to fit in a 32-bit unsigned int. */
if (h5->cmode & NC_CLASSIC_MODEL)
if((unsigned long) len > X_INT_MAX) /* Backward compat */
return NC_EDIMSIZE;
/* Make sure the name is not already in use. */
for (dim = grp->dim; dim; dim = dim->next)
if (!strncmp(dim->name, norm_name, NC_MAX_NAME))
return NC_ENAMEINUSE;
/* Add a dimension to the list. The ID must come from the file
* information, since dimids are visible in more than one group. */
nc4_dim_list_add(&grp->dim);
grp->dim->dimid = grp->file->nc4_info->next_dimid++;
/* Initialize the metadata for this dimension. */
if (!(grp->dim->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(grp->dim->name, norm_name);
grp->dim->len = len;
grp->dim->dirty++;
if (len == NC_UNLIMITED)
grp->dim->unlimited++;
/* Pass back the dimid. */
if (idp)
*idp = grp->dim->dimid;
return retval;
}
/* Given dim name, find its id. */
int
NCD_inq_dimid(int ncid, const char *name, int *idp)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
NC_DIM_INFO_T *dim;
char norm_name[NC_MAX_NAME + 1];
int finished = 0;
int retval;
LOG((2, "nc_inq_dimid: ncid 0x%x name %s", ncid, name));
/* Find metadata for this file. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Handle netcdf-3 files. */
assert(h5);
assert(nc && grp);
/* Normalize name. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Go through each dim and check for a name match. */
for (g = grp; g && !finished; g = g->parent)
for (dim = g->dim; dim; dim = dim->next)
if (!strncmp(dim->name, norm_name, NC_MAX_NAME))
{
if (idp)
*idp = dim->dimid;
finished++;
return NC_NOERR;
}
return NC_EBADDIM;
}
/* Find out name and len of a dim. For an unlimited dimension, the
length is the largest lenght so far written. If the name of lenp
pointers are NULL, they will be ignored. */
int
NCD_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
{
NC_FILE_INFO_T *nc;
NC_HDF5_FILE_INFO_T *h5;
NC_GRP_INFO_T *grp, *dim_grp;
NC_DIM_INFO_T *dim;
int ret = NC_NOERR;
LOG((2, "nc_inq_dim: ncid 0x%x dimid %d", ncid, dimid));
/* Find our global metadata structure. */
if ((ret = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return ret;
/* Take care of netcdf-3 files. */
assert(h5);
assert(nc && grp);
/* Find the dimension and its home group. */
if ((ret = nc4_find_dim(grp, dimid, &dim, &dim_grp)))
return ret;
assert(dim);
/* Return the dimension name, if the caller wants it. */
if (name && dim->name)
strcpy(name, dim->name);
/* Return the dimension length, if the caller wants it. */
if (lenp)
{
if (dim->unlimited)
{
/* Since this is an unlimited dimension, go to the file
and see how many records there are. Take the max number
of records from all the vars that share this
dimension. */
*lenp = 0;
if ((ret = nc4_find_dim_len(dim_grp, dimid, &lenp)))
return ret;
}
else
{
if (dim->too_long)
{
ret = NC_EDIMSIZE;
*lenp = NC_MAX_UINT;
}
else
*lenp = dim->len;
}
}
return ret;
}
/* Rename a dimension, for those who like to prevaricate. */
int
NCD_rename_dim(int ncid, int dimid, const char *name)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_DIM_INFO_T *dim;
char norm_name[NC_MAX_NAME + 1];
int retval;
if (!name)
return NC_EINVAL;
LOG((2, "nc_rename_dim: ncid 0x%x dimid %d name %s", ncid,
dimid, name));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
assert(nc);
/* Handle netcdf-3 cases. */
assert(h5);
assert(h5 && grp);
/* Trying to write to a read-only file? No way, Jose! */
if (h5->no_write)
return NC_EPERM;
/* Make sure this is a valid netcdf name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* Make sure the new name is not already in use in this group. */
for (dim = grp->dim; dim; dim = dim->next)
if (!strncmp(dim->name, norm_name, NC_MAX_NAME))
return NC_ENAMEINUSE;
/* Find the dim. */
for (dim = grp->dim; dim; dim = dim->next)
if (dim->dimid == dimid)
break;
if (!dim)
return NC_EBADDIM;
/* If not in define mode, switch to it, unless the new name is
* shorter. (This is in accordance with the v3 interface.) */
/* if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(dim->name)) */
/* { */
/* if (h5->cmode & NC_CLASSIC_MODEL) */
/* return NC_ENOTINDEFINE; */
/* if ((retval = nc_redef(ncid))) */
/* return retval; */
/* } */
/* Save the old name, we'll need it to rename this object when we
* sync to HDF5 file. But if there already is an old_name saved,
* just stick with what we've got, since the user might be renaming
* the crap out of this thing, without ever syncing with the
* file. When the sync does take place, we only need the original
* name of the dim, not any of the intermediate ones. If the user
* could just make up his mind, we could all get on to writing some
* data... */
if (!dim->old_name)
{
if (!(dim->old_name = malloc((strlen(dim->name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(dim->old_name, dim->name);
}
/* Give the dimension its new name in metadata. UTF8 normalization
* has been done. */
free(dim->name);
if (!(dim->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(dim->name, norm_name);
return NC_NOERR;
}
/* Returns an array of unlimited dimension ids.The user can get the
number of unlimited dimensions by first calling this with NULL for
the second pointer.
*/
int
NCD_inq_unlimdims(int ncid, int *nunlimdimsp, int *unlimdimidsp)
{
NC_DIM_INFO_T *dim;
NC_GRP_INFO_T *grp;
NC_FILE_INFO_T *nc;
NC_HDF5_FILE_INFO_T *h5;
int num_unlim = 0;
int retval;
LOG((2, "nc_inq_unlimdims: ncid 0x%x", ncid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Get our dim info. */
assert(h5);
{
for (dim=grp->dim; dim; dim=dim->next)
{
if (dim->unlimited)
{
if (unlimdimidsp)
unlimdimidsp[num_unlim] = dim->dimid;
num_unlim++;
}
}
}
/* Give the number if the user wants it. */
if (nunlimdimsp)
*nunlimdimsp = num_unlim;
return NC_NOERR;
}

110
libdiskless/ncddispatch.c
View File

@ -1,110 +0,0 @@
/*! \file \internal
Contains the dispatch functions for diskless interface.
Copyright 2011, UCAR/Unidata. See COPYRIGHT file for copying and
redistribution conditions.
*/
#include <stdlib.h>
#include "nc.h"
#include "ncdispatch.h"
#include "ncddispatch.h"
NC_Dispatch NCD_dispatcher =
{
NC_DISPATCH_NCD,
NCD_new_nc,
NCD_create,
NCD_open,
NCD_redef,
NCD__enddef,
NCD_sync,
NCD_abort,
NCD_close,
NCD_set_fill,
NCD_inq_base_pe,
NCD_set_base_pe,
NCD_inq_format,
NCD_inq,
NCD_inq_type,
NCD_def_dim,
NCD_inq_dimid,
NCD_inq_dim,
NCD_inq_unlimdim,
NCD_rename_dim,
NCD_inq_att,
NCD_inq_attid,
NCD_inq_attname,
NCD_rename_att,
NCD_del_att,
NCD_get_att,
NCD_put_att,
NCD_def_var,
NCD_inq_varid,
NCD_rename_var,
NCD_get_vara,
NCD_put_vara,
NCDEFAULT_get_vars,
NCDEFAULT_put_vars,
NCDEFAULT_get_varm,
NCDEFAULT_put_varm,
NCD_inq_var_all,
NCD_show_metadata,
NCD_inq_unlimdims,
NCD_var_par_access,
NCD_inq_ncid,
NCD_inq_grps,
NCD_inq_grpname,
NCD_inq_grpname_full,
NCD_inq_grp_parent,
NCD_inq_grp_full_ncid,
NCD_inq_varids,
NCD_inq_dimids,
NCD_inq_typeids,
NCD_inq_type_equal,
NCD_def_grp,
NCD_inq_user_type,
NCD_inq_typeid,
NCD_def_compound,
NCD_insert_compound,
NCD_insert_array_compound,
NCD_inq_compound_field,
NCD_inq_compound_fieldindex,
NCD_def_vlen,
NCD_put_vlen_element,
NCD_get_vlen_element,
NCD_def_enum,
NCD_insert_enum,
NCD_inq_enum_member,
NCD_inq_enum_ident,
NCD_def_opaque,
NCD_def_var_deflate,
NCD_def_var_fletcher32,
NCD_def_var_chunking,
NCD_def_var_fill,
NCD_def_var_endian,
NCD_set_var_chunk_cache,
NCD_get_var_chunk_cache,
};
/* NC_Dispatch* NCD_dispatch_table = NULL; /\* Moved here from ddispatch.c *\/ */
/* int */
/* NCD_initialize(void) */
/* { */
/* NCD_dispatch_table = &NCD_dispatcher; */
/* return NC_NOERR; */
/* } */

270
libdiskless/ncddispatch.h
View File

@ -1,270 +0,0 @@
/*********************************************************************
* Copyright 2010, UCAR/Unidata. See netcdf/COPYRIGHT file for copying
* and redistribution conditions.
*
* This header file contains the prototypes for the netCDF-4 versions
* of all the netCDF functions.
*********************************************************************/
#ifndef _NCDDISPATCH_H
#define _NCDDISPATCH_H
#include <stddef.h> /* size_t, ptrdiff_t */
#include <errno.h> /* netcdf functions sometimes return system errors */
#include "ncdispatch.h"
#if defined(__cplusplus)
extern "C" {
#endif
extern int
NCD_create(const char *path, int cmode,
size_t initialsz, int basepe, size_t *chunksizehintp,
int useparallel, void* parameters,
NC_Dispatch*, NC**);
extern int
NCD_open(const char *path, int mode,
int basepe, size_t *chunksizehintp,
int use_parallel, void* parameters,
NC_Dispatch*, NC**);
extern int
NCD_new_nc(NC**);
extern int
NCD_free_nc(NC*);
extern int
NCD_redef(int ncid);
extern int
NCD__enddef(int ncid, size_t h_minfree, size_t v_align,
size_t v_minfree, size_t r_align);
extern int
NCD_sync(int ncid);
extern int
NCD_abort(int ncid);
extern int
NCD_close(int ncid);
extern int
NCD_set_fill(int ncid, int fillmode, int *old_modep);
extern int
NCD_set_base_pe(int ncid, int pe);
extern int
NCD_inq_base_pe(int ncid, int *pe);
extern int
NCD_inq_format(int ncid, int *formatp);
extern int
NCD_inq(int ncid, int *ndimsp, int *nvarsp, int *nattsp, int *unlimdimidp);
extern int
NCD_inq_type(int, nc_type, char *, size_t *);
/* Begin _dim */
extern int
NCD_def_dim(int ncid, const char *name, size_t len, int *idp);
extern int
NCD_inq_dimid(int ncid, const char *name, int *idp);
extern int
NCD_inq_dim(int ncid, int dimid, char *name, size_t *lenp);
extern int
NCD_inq_unlimdim(int ncid, int *unlimdimidp);
extern int
NCD_rename_dim(int ncid, int dimid, const char *name);
/* End _dim */
/* Begin _att */
extern int
NCD_inq_att(int ncid, int varid, const char *name,
nc_type *xtypep, size_t *lenp);
extern int
NCD_inq_attid(int ncid, int varid, const char *name, int *idp);
extern int
NCD_inq_attname(int ncid, int varid, int attnum, char *name);
extern int
NCD_rename_att(int ncid, int varid, const char *name, const char *newname);
extern int
NCD_del_att(int ncid, int varid, const char*);
/* End _att */
/* Begin {put,get}_att */
extern int
NCD_get_att(int ncid, int varid, const char *name, void *value, nc_type);
extern int
NCD_put_att(int ncid, int varid, const char *name, nc_type datatype,
size_t len, const void *value, nc_type);
/* End {put,get}_att */
/* Begin _var */
extern int
NCD_def_var(int ncid, const char *name,
nc_type xtype, int ndims, const int *dimidsp, int *varidp);
extern int
NCD_inq_var_all(int ncid, int varid, char *name, nc_type *xtypep,
int *ndimsp, int *dimidsp, int *nattsp,
int *shufflep, int *deflatep, int *deflate_levelp,
int *fletcher32p, int *contiguousp, size_t *chunksizesp,
int *no_fill, void *fill_valuep, int *endiannessp,
int *options_maskp, int *pixels_per_blockp);
extern int
NCD_inq_varid(int ncid, const char *name, int *varidp);
extern int
NCD_rename_var(int ncid, int varid, const char *name);
extern int
NCD_put_vara(int ncid, int varid,
const size_t *start, const size_t *count,
const void *value, nc_type);
extern int
NCD_get_vara(int ncid, int varid,
const size_t *start, const size_t *count,
void *value, nc_type);
/* End _var */
/* netCDF4 API only */
extern int
NCD_var_par_access(int, int, int);
extern int
NCD_inq_ncid(int, const char *, int *);
extern int
NCD_inq_grps(int, int *, int *);
extern int
NCD_inq_grpname(int, char *);
extern int
NCD_inq_grpname_full(int, size_t *, char *);
extern int
NCD_inq_grp_parent(int, int *);
extern int
NCD_inq_grp_full_ncid(int, const char *, int *);
extern int
NCD_inq_varids(int, int * nvars, int *);
extern int
NCD_inq_dimids(int, int * ndims, int *, int);
extern int
NCD_inq_typeids(int, int * ntypes, int *);
extern int
NCD_inq_type_equal(int, nc_type, int, nc_type, int *);
extern int
NCD_def_grp(int, const char *, int *);
extern int
NCD_inq_user_type(int, nc_type, char *, size_t *, nc_type *,
size_t *, int *);
extern int
NCD_def_compound(int, size_t, const char *, nc_type *);
extern int
NCD_insert_compound(int, nc_type, const char *, size_t, nc_type);
extern int
NCD_insert_array_compound(int, nc_type, const char *, size_t,
nc_type, int, const int *);
extern int
NCD_inq_typeid(int, const char *, nc_type *);
extern int
NCD_inq_compound_field(int, nc_type, int, char *, size_t *,
nc_type *, int *, int *);
extern int
NCD_inq_compound_fieldindex(int, nc_type, const char *, int *);
extern int
NCD_def_vlen(int, const char *, nc_type base_typeid, nc_type *);
extern int
NCD_put_vlen_element(int, int, void *, size_t, const void *);
extern int
NCD_get_vlen_element(int, int, const void *, size_t *, void *);
extern int
NCD_def_enum(int, nc_type, const char *, nc_type *);
extern int
NCD_insert_enum(int, nc_type, const char *, const void *);
extern int
NCD_inq_enum_member(int, nc_type, int, char *, void *);
extern int
NCD_inq_enum_ident(int, nc_type, long long, char *);
extern int
NCD_def_opaque(int, size_t, const char *, nc_type *);
extern int
NCD_def_var_deflate(int, int, int, int, int);
extern int
NCD_def_var_fletcher32(int, int, int);
extern int
NCD_def_var_chunking(int, int, int, const size_t *);
extern int
NCD_def_var_fill(int, int, int, const void *);
extern int
NCD_def_var_endian(int, int, int);
extern int
NCD_set_var_chunk_cache(int, int, size_t, size_t, float);
extern int
NCD_get_var_chunk_cache(int, int, size_t *, size_t *, float *);
extern int
NCD_inq_unlimdims(int, int *, int *);
extern int
NCD_show_metadata(int);
/* extern int */
/* NCD_initialize(void); */
#if defined(__cplusplus)
}
#endif
#endif /*_NCDDISPATCH_H */

522
libdiskless/ncdfile.c
View File

@ -1,522 +0,0 @@
/** \file
The netCDF diskless API file functions.
Copyright 2011, University Corporation for Atmospheric Research. See
COPYRIGHT file for copying and redistribution conditions.
*/
#include "nc4internal.h"
#include "nc.h"
#include <H5DSpublic.h>
#include "ncddispatch.h"
#include "ncdispatch.h"
#define MIN_DEFLATE_LEVEL 0
#define MAX_DEFLATE_LEVEL 9
/* These are the special attributes added by the HDF5 dimension scale
* API. They will be ignored by netCDF-4. */
#define REFERENCE_LIST "REFERENCE_LIST"
#define CLASS "CLASS"
#define DIMENSION_LIST "DIMENSION_LIST"
#define NAME "NAME"
static int NCD_enddef(int ncid);
/* This is set by nc_set_default_format in libsrc/nc.c. */
extern int default_create_format;
/* For performance, fill this array only the first time, and keep it
* in global memory for each further use. */
#define NUM_TYPES 12
int nc4_free_global_hdf_string_typeid();
/** \ingroup diskless
Create a diskless file.
\param path The file name of the new file.
\param cmode The creation mode flag.
\param initialsz Ignored by this function.
\param basepe Ignored by this function.
\param chunksizehintp Ignored by this function.
\param use_parallel Ignored by this function.
\param mpidata Ignored by this function.
\param dispatch Pointer to the dispatch table for this file.
\param ncpp Pointer to start of linked list of open files.
\return ::NC_EINVAL Invalid input (check cmode).
*/
int
NCD_create(const char* path, int cmode, size_t initialsz, int basepe,
size_t *chunksizehintp, int use_parallel, void *mpidata,
NC_Dispatch *dispatch, NC **ncpp)
{
NC_FILE_INFO_T *nc_file = NULL;
int res;
assert(ncpp && path);
LOG((1, "NCD_create_file: path %s cmode 0x%x", path, cmode));
/* Check the cmode for validity. */
if (cmode & NC_MPIIO || cmode & NC_MPIPOSIX
|| cmode & NC_PNETCDF)
return NC_EINVAL;
if (!(cmode & NC_NETCDF4) || !(cmode & NC_CLASSIC_MODEL))
return NC_EINVAL;
/* Allocate the storage for this file info struct, and fill it with
zeros. This adds the file metadata to the global list. */
if ((res = nc4_file_list_add(&nc_file, dispatch)))
return res;
/* Apply default create format. */
if (default_create_format == NC_FORMAT_64BIT)
cmode |= NC_64BIT_OFFSET;
else if (default_create_format == NC_FORMAT_NETCDF4)
cmode |= NC_NETCDF4;
else if (default_create_format == NC_FORMAT_NETCDF4_CLASSIC)
{
cmode |= NC_NETCDF4;
cmode |= NC_CLASSIC_MODEL;
}
LOG((2, "cmode after applying default format: 0x%x", cmode));
/* Fill in information we already know. */
nc_file->int_ncid = nc_file->ext_ncid;
/* Add necessary structs to hold netcdf-4 file data. */
if ((res = nc4_nc4f_list_add(nc_file, path, (NC_WRITE | cmode))))
return res;
assert(nc_file->nc4_info && nc_file->nc4_info->root_grp);
/* Define mode gets turned on automatically on create. */
nc_file->nc4_info->flags |= NC_INDEF;
*ncpp = (NC *)nc_file;
return NC_NOERR;
}
/* Given index, get the HDF5 name of an object and the class of the
* object (group, type, dataset, etc.). This function will try to use
* creation ordering, but if that fails it will use default
* (i.e. alphabetical) ordering. (This is necessary to read existing
* HDF5 archives without creation ordering). */
/* static int */
/* get_name_by_idx(NC_HDF5_FILE_INFO_T *h5, hid_t hdf_grpid, int i, */
/* int *obj_class, char *obj_name) */
/* { */
/* H5O_info_t obj_info; */
/* H5_index_t idx_field = H5_INDEX_CRT_ORDER; */
/* ssize_t size; */
/* herr_t res; */
/* /\* These HDF5 macros prevent an HDF5 error message when a */
/* * non-creation-ordered HDF5 file is opened. *\/ */
/* H5E_BEGIN_TRY { */
/* res = H5Oget_info_by_idx(hdf_grpid, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, */
/* i, &obj_info, H5P_DEFAULT); */
/* } H5E_END_TRY; */
/* /\* Creation ordering not available, so make sure this file is */
/* * opened for read-only access. This is a plain old HDF5 file being */
/* * read by netCDF-4. *\/ */
/* if (res < 0) */
/* { */
/* if (H5Oget_info_by_idx(hdf_grpid, ".", H5_INDEX_NAME, H5_ITER_INC, */
/* i, &obj_info, H5P_DEFAULT) < 0) */
/* return NC_EHDFERR; */
/* if (!h5->no_write) */
/* return NC_ECANTWRITE; */
/* h5->ignore_creationorder = 1; */
/* idx_field = H5_INDEX_NAME; */
/* } */
/* *obj_class = obj_info.type; */
/* if ((size = H5Lget_name_by_idx(hdf_grpid, ".", idx_field, H5_ITER_INC, i, */
/* NULL, 0, H5P_DEFAULT)) < 0) */
/* return NC_EHDFERR; */
/* if (size > NC_MAX_NAME) */
/* return NC_EMAXNAME; */
/* if (H5Lget_name_by_idx(hdf_grpid, ".", idx_field, H5_ITER_INC, i, */
/* obj_name, size+1, H5P_DEFAULT) < 0) */
/* return NC_EHDFERR; */
/* LOG((4, "get_name_by_idx: encountered HDF5 object obj_name %s", obj_name)); */
/* return NC_NOERR; */
/* } */
/** \internal
This struct is used to pass information back from the callback
function used with H5Literate.
*/
struct nc_hdf5_link_info
{
char name[NC_MAX_NAME + 1];
H5I_type_t obj_type;
};
int
NCD_open(const char *path, int mode, int basepe, size_t *chunksizehintp,
int use_parallel, void *mpidata, NC_Dispatch *dispatch, NC **ncpp)
{
return NC_EINVAL;
}
/* Unfortunately HDF only allows specification of fill value only when
a dataset is created. Whereas in netcdf, you first create the
variable and then (optionally) specify the fill value. To
accomplish this in HDF5 I have to delete the dataset, and recreate
it, with the fill value specified. */
int
NCD_set_fill(int ncid, int fillmode, int *old_modep)
{
NC_FILE_INFO_T *nc;
LOG((2, "nc_set_fill: ncid 0x%x fillmode %d", ncid, fillmode));
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Is this a netcdf-3 file? */
assert(nc->nc4_info);
/* Trying to set fill on a read-only file? You sicken me! */
if (nc->nc4_info->no_write)
return NC_EPERM;
/* Did you pass me some weird fillmode? */
if (fillmode != NC_FILL && fillmode != NC_NOFILL)
return NC_EINVAL;
/* If the user wants to know, tell him what the old mode was. */
if (old_modep)
*old_modep = nc->nc4_info->fill_mode;
nc->nc4_info->fill_mode = fillmode;
return NC_NOERR;
}
/* Put the file back in redef mode. This is done automatically for
* netcdf-4 files, if the user forgets. */
int
NCD_redef(int ncid)
{
NC_FILE_INFO_T *nc;
LOG((1, "nc_redef: ncid 0x%x", ncid));
/* Find this file's metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Handle netcdf-3 files. */
assert(nc->nc4_info);
/* If we're already in define mode, return an error. */
if (nc->nc4_info->flags & NC_INDEF)
return NC_EINDEFINE;
/* If the file is read-only, return an error. */
if (nc->nc4_info->no_write)
return NC_EPERM;
/* Set define mode. */
nc->nc4_info->flags |= NC_INDEF;
/* For nc_abort, we need to remember if we're in define mode as a
redef. */
nc->nc4_info->redef++;
return NC_NOERR;
}
/* For netcdf-4 files, this just calls nc_enddef, ignoring the extra
* parameters. */
int
NCD__enddef(int ncid, size_t h_minfree, size_t v_align,
size_t v_minfree, size_t r_align)
{
NC_FILE_INFO_T *nc;
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
return NCD_enddef(ncid);
}
/* Take the file out of define mode. This is called automatically for
* netcdf-4 files, if the user forgets. */
static int NCD_enddef(int ncid)
{
NC_FILE_INFO_T *nc;
LOG((1, "nc_enddef: ncid 0x%x", ncid));
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Take care of netcdf-3 files. */
assert(nc->nc4_info);
return nc4_enddef_netcdf4_file(nc->nc4_info);
}
/* This function will write all changed metadata, and (someday) reread
* all metadata from the file. */
static int
sync_netcdf4_file(NC_HDF5_FILE_INFO_T *h5)
{
int retval;
assert(h5);
LOG((3, "sync_netcdf4_file"));
/* If we're in define mode, that's an error, for strict nc3 rules,
* otherwise, end define mode. */
if (h5->flags & NC_INDEF)
{
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_EINDEFINE;
/* Turn define mode off. */
h5->flags ^= NC_INDEF;
/* Redef mode needs to be tracked seperately for nc_abort. */
h5->redef = 0;
}
#ifdef LOGGING
/* This will print out the names, types, lens, etc of the vars and
atts in the file, if the logging level is 2 or greater. */
log_metadata_nc(h5->root_grp->file);
#endif
/* Write any metadata that has changed. */
if (!(h5->cmode & NC_NOWRITE))
{
if ((retval = nc4_rec_write_types(h5->root_grp)))
return retval;
if ((retval = nc4_rec_write_metadata(h5->root_grp)))
return retval;
}
H5Fflush(h5->hdfid, H5F_SCOPE_GLOBAL);
/* Reread all the metadata. */
/*if ((retval = nc4_rec_read_metadata(grp)))
return retval;*/
return retval;
}
/* Flushes all buffers associated with the file, after writing all
changed metadata. This may only be called in data mode. */
int
NCD_sync(int ncid)
{
NC_FILE_INFO_T *nc;
int retval;
LOG((2, "nc_sync: ncid 0x%x", ncid));
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Take care of netcdf-3 files. */
assert(nc->nc4_info);
/* If we're in define mode, we can't sync. */
if (nc->nc4_info && nc->nc4_info->flags & NC_INDEF)
{
if (nc->nc4_info->cmode & NC_CLASSIC_MODEL)
return NC_EINDEFINE;
if ((retval = nc_enddef(ncid)))
return retval;
}
return sync_netcdf4_file(nc->nc4_info);
}
/* This function will free all allocated metadata memory, and close
the HDF5 file. The group that is passed in must be the root group
of the file. */
static int
close_netcdf4_file(NC_HDF5_FILE_INFO_T *h5, int abort)
{
int retval;
assert(h5 && h5->root_grp);
LOG((3, "close_netcdf4_file: h5->path %s abort %d",
h5->path, abort));
/* According to the docs, always end define mode on close. */
if (h5->flags & NC_INDEF)
h5->flags ^= NC_INDEF;
/* Delete all the list contents for vars, dims, and atts, in each
* group. */
if ((retval = nc4_rec_grp_del(&h5->root_grp, h5->root_grp)))
return retval;
/* Delete the memory for the path, if it's been allocated. */
if (h5->path)
free(h5->path);
/* Free the nc4_info struct. */
free(h5);
return NC_NOERR;
}
/* From the netcdf-3 docs: The function nc_abort just closes the
netCDF dataset, if not in define mode. If the dataset is being
created and is still in define mode, the dataset is deleted. If
define mode was entered by a call to nc_redef, the netCDF dataset
is restored to its state before definition mode was entered and the
dataset is closed. */
int
NCD_abort(int ncid)
{
NC_FILE_INFO_T *nc;
int delete_file = 0;
char path[NC_MAX_NAME + 1];
int retval = NC_NOERR;
LOG((2, "nc_abort: ncid 0x%x", ncid));
/* Find metadata for this file. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* If this is a netcdf-3 file, let the netcdf-3 library handle it. */
assert(nc->nc4_info);
/* If we're in define mode, but not redefing the file, delete it. */
if (nc->nc4_info->flags & NC_INDEF && !nc->nc4_info->redef)
{
delete_file++;
strcpy(path, nc->nc4_info->path);
/*strcpy(path, nc->path);*/
}
/* Free any resources the netcdf-4 library has for this file's
* metadata. */
if ((retval = close_netcdf4_file(nc->nc4_info, 1)))
return retval;
/* Delete the file, if we should. */
if (delete_file)
remove(path);
/* Delete this entry from our list of open files. */
nc4_file_list_del(nc);
return retval;
}
/* Close the netcdf file, writing any changes first. */
int
NCD_close(int ncid)
{
NC_GRP_INFO_T *grp;
NC_FILE_INFO_T *nc;
NC_HDF5_FILE_INFO_T *h5;
int retval;
LOG((1, "nc_close: ncid 0x%x", ncid));
/* Find our metadata for this file. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
assert(h5 && nc);
/* This must be the root group. */
if (grp->parent)
return NC_EBADGRPID;
/* Call the nc4 close. */
if ((retval = close_netcdf4_file(grp->file->nc4_info, 0)))
return retval;
/* Delete this entry from our list of open files. */
if (nc->path)
free(nc->path);
nc4_file_list_del(nc);
/* Reset the ncid numbers if there are no more files open. */
if(count_NCList() == 0)
nc4_file_list_free();
return NC_NOERR;
}
/* It's possible for any of these pointers to be NULL, in which case
don't try to figure out that value. */
int
NCD_inq(int ncid, int *ndimsp, int *nvarsp, int *nattsp, int *unlimdimidp)
{
NC_FILE_INFO_T *nc;
NC_HDF5_FILE_INFO_T *h5;
NC_GRP_INFO_T *grp;
NC_DIM_INFO_T *dim;
NC_ATT_INFO_T *att;
NC_VAR_INFO_T *var;
int retval;
LOG((2, "nc_inq: ncid 0x%x", ncid));
/* Find file metadata. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Netcdf-3 files are already taken care of. */
assert(h5 && grp && nc);
/* Count the number of dims, vars, and global atts. */
if (ndimsp)
{
*ndimsp = 0;
for (dim = grp->dim; dim; dim = dim->next)
(*ndimsp)++;
}
if (nvarsp)
{
*nvarsp = 0;
for (var = grp->var; var; var= var->next)
(*nvarsp)++;
}
if (nattsp)
{
*nattsp = 0;
for (att = grp->att; att; att = att->next)
(*nattsp)++;
}
if (unlimdimidp)
{
/* Default, no unlimited dimension */
int found = 0;
*unlimdimidp = -1;
/* If there's more than one unlimited dim, which was not possible
with netcdf-3, then only the last unlimited one will be reported
back in xtendimp. */
/* Note that this code is inconsistent with nc_inq_unlimid() */
for (dim = grp->dim; dim; dim = dim->next)
if (dim->unlimited)
{
*unlimdimidp = dim->dimid;
found++;
break;
}
}
return NC_NOERR;
}

68
libdiskless/ncdfunc.c
View File

@ -1,68 +0,0 @@
/* \file \internal
Some functions for diskless API.
Copyright 2011, University Corporation for Atmospheric Research. See
COPYRIGHT file for copying and redistribution conditions.
*/
#include "nc4internal.h"
#include "ncddispatch.h"
#include "nc3dispatch.h"
/* This function only does anything for netcdf-3 files. */
int
NCD_set_base_pe(int ncid, int pe)
{
NC_FILE_INFO_T *nc;
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
if (nc->nc4_info)
return NC_ENOTNC3;
return NC3_set_base_pe(nc->int_ncid, pe);
}
/* This function only does anything for netcdf-3 files. */
int
NCD_inq_base_pe(int ncid, int *pe)
{
NC_FILE_INFO_T *nc;
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
if (nc->nc4_info)
return NC_ENOTNC3;
return NC3_inq_base_pe(nc->int_ncid, pe);
}
/* Get the format (i.e. classic, 64-bit-offset, or netcdf-4) of an
* open file. */
int
NCD_inq_format(int ncid, int *formatp)
{
NC_FILE_INFO_T *nc;
LOG((2, "nc_inq_format: ncid 0x%x", ncid));
if (!formatp)
return NC_NOERR;
/* Find the file metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* If this isn't a netcdf-4 file, pass this call on to the netcdf-3
* library. */
if (!nc->nc4_info)
return NC3_inq_format(nc->int_ncid, formatp);
/* Otherwise, this is a netcdf-4 file. Check if classic NC3 rules
* are in effect for this file. */
if (nc->nc4_info->cmode & NC_CLASSIC_MODEL)
*formatp = NC_FORMAT_NETCDF4_CLASSIC;
else
*formatp = NC_FORMAT_NETCDF4;
return NC_NOERR;
}

441
libdiskless/ncdgrp.c
View File

@ -1,441 +0,0 @@
/*
This file is part of netcdf-4, a netCDF-like interface for HDF5, or a
HDF5 backend for netCDF, depending on your point of view.
This file handles the nc4 groups.
Copyright 2005, University Corporation for Atmospheric Research. See
netcdf-4/docs/COPYRIGHT file for copying and redistribution
conditions.
$Id: nc4grp.c,v 1.44 2010/05/25 17:54:23 dmh Exp $
*/
#include "nc4internal.h"
#include "ncddispatch.h"
/* Create a group. It's ncid is returned in the new_ncid pointer. */
int
NCD_def_grp(int parent_ncid, const char *name, int *new_ncid)
{
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
char norm_name[NC_MAX_NAME + 1];
int retval;
LOG((2, "nc_def_grp: parent_ncid 0x%x name %s", parent_ncid, name));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(parent_ncid, &grp, &h5)))
return retval;
if (!h5)
return NC_ENOTNC4;
/* Check and normalize the name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* Check that this name is not in use as a var, grp, or type. */
if ((retval = nc4_check_dup_name(grp, norm_name)))
return retval;
/* No groups in netcdf-3! */
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_ESTRICTNC3;
/* If it's not in define mode, switch to define mode. */
if (!(h5->flags & NC_INDEF))
if ((retval = NCD_redef(parent_ncid)))
return retval;
/* Update internal lists to reflect new group. The actual HDF5
* group creation will be done when metadata is written by a
* sync. */
if ((retval = nc4_grp_list_add(&(grp->children), h5->next_nc_grpid,
grp, grp->file, norm_name, &g)))
return retval;
if (new_ncid)
*new_ncid = grp->file->ext_ncid | h5->next_nc_grpid;
h5->next_nc_grpid++;
return NC_NOERR;
}
/* Given an ncid and group name (NULL gets root group), return
* the ncid of that group. */
int
NCD_inq_ncid(int ncid, const char *name, int *grp_ncid)
{
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
char norm_name[NC_MAX_NAME + 1];
int retval;
LOG((2, "nc_inq_ncid: ncid 0x%x name %s", ncid, name));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* Groups only work with netCDF-4/HDF5 files... */
if (!h5)
return NC_ENOTNC4;
/* Normalize name. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Look through groups for one of this name. */
for (g = grp->children; g; g = g->next)
if (!strcmp(norm_name, g->name)) /* found it! */
{
if (grp_ncid)
*grp_ncid = grp->file->ext_ncid | g->nc_grpid;
return NC_NOERR;
}
/* If we got here, we didn't find the named group. */
return NC_ENOGRP;
}
/* Given a location id, return the number of groups it contains, and
* an array of their locids. */
int
NCD_inq_grps(int ncid, int *numgrps, int *ncids)
{
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
int num = 0;
int retval;
LOG((2, "nc_inq_grps: ncid 0x%x", ncid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* For netCDF-3 files, just report zero groups. */
if (!h5)
{
if (numgrps)
*numgrps = 0;
return NC_NOERR;
}
/* Count the number of groups in this group. */
for (g = grp->children; g; g = g->next)
{
if (ncids)
{
/* Combine the nc_grpid in a bitwise or with the ext_ncid,
* which allows the returned ncid to carry both file and
* group information. */
*ncids = g->nc_grpid | g->file->ext_ncid;
ncids++;
}
num++;
}
if (numgrps)
*numgrps = num;
return NC_NOERR;
}
/* Given locid, find name of group. (Root group is named "/".) */
int
NCD_inq_grpname(int ncid, char *name)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
int retval;
LOG((2, "nc_inq_grpname: ncid 0x%x", ncid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
if (name)
{
if (!h5)
strcpy(name, "/");
else
strcpy(name, grp->name);
}
return NC_NOERR;
}
/* Find the full path name to the group represented by ncid. Either
* pointer argument may be NULL; pass a NULL for the third parameter
* to get the length of the full path name. The length will not
* include room for a null pointer. */
EXTERNL int
NCD_inq_grpname_full(int ncid, size_t *lenp, char *full_name)
{
char *name, grp_name[NC_MAX_NAME + 1];
int g, id = ncid, parent_id, *gid;
int i, ret = NC_NOERR;
/* How many generations? */
for (g = 0; !nc_inq_grp_parent(id, &parent_id); g++, id = parent_id)
;
/* Allocate storage. */
if (!(name = malloc((g + 1) * (NC_MAX_NAME + 1) + 1)))
return NC_ENOMEM;
if (!(gid = malloc((g + 1) * sizeof(int))))
{
free(name);
return NC_ENOMEM;
}
assert(name && gid);
/* Always start with a "/" for the root group. */
strcpy(name, "/");
/* Get the ncids for all generations. */
gid[0] = ncid;
for (i = 1; i < g && !ret; i++)
ret = nc_inq_grp_parent(gid[i - 1], &gid[i]);
/* Assemble the full name. */
for (i = g - 1; !ret && i >= 0 && !ret; i--)
{
if ((ret = nc_inq_grpname(gid[i], grp_name)))
break;
strcat(name, grp_name);
if (i)
strcat(name, "/");
}
/* Give the user the length of the name, if he wants it. */
if (!ret && lenp)
*lenp = strlen(name);
/* Give the user the name, if he wants it. */
if (!ret && full_name)
strcpy(full_name, name);
free(gid);
free(name);
return ret;
}
/* Find the parent ncid of a group. For the root group, return
* NC_ENOGRP error. *Now* I know what kind of tinfoil hat wearing nut
* job would call this function with a NULL pointer for parent_ncid -
* Russ Rew!! */
int
NCD_inq_grp_parent(int ncid, int *parent_ncid)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
int retval;
LOG((2, "nc_inq_grp_parent: ncid 0x%x", ncid));
/* Find info for this file and group. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* Groups only work with netCDF-4/HDF5 files... */
if (!h5)
return NC_ENOGRP;
/* Set the parent ncid, if there is one. */
if (grp->parent)
{
if (parent_ncid)
*parent_ncid = grp->file->ext_ncid | grp->parent->nc_grpid;
}
else
return NC_ENOGRP;
return NC_NOERR;
}
/* Given a full name and ncid, find group ncid. */
int
NCD_inq_grp_full_ncid(int ncid, const char *full_name, int *grp_ncid)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
int id1 = ncid, id2;
char *cp, *full_name_cpy;
int ret;
if (!full_name)
return NC_EINVAL;
/* Find info for this file and group, and set pointer to each. */
if ((ret = nc4_find_grp_h5(ncid, &grp, &h5)))
return ret;
/* Copy full_name because strtok messes with the value it works
* with, and we don't want to mess up full_name. */
if (!(full_name_cpy = malloc(strlen(full_name) + 1)))
return NC_ENOMEM;
strcpy(full_name_cpy, full_name);
/* Get the first part of the name. */
if (!(cp = strtok(full_name_cpy, "/")))
{
/* If "/" is passed, and this is the root group, return the root
* group id. */
if (!grp->parent)
id2 = ncid;
else
{
free(full_name_cpy);
return NC_ENOGRP;
}
}
else
{
/* Keep parsing the string. */
for (; cp; id1 = id2)
{
if ((ret = nc_inq_grp_ncid(id1, cp, &id2)))
{
free(full_name_cpy);
return ret;
}
cp = strtok(NULL, "/");
}
}
/* Give the user the requested value. */
if (grp_ncid)
*grp_ncid = id2;
free(full_name_cpy);
return NC_NOERR;
}
/* Get a list of ids for all the variables in a group. */
int
NCD_inq_varids(int ncid, int *nvars, int *varids)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
int v, num_vars = 0;
int retval;
LOG((2, "nc_inq_varids: ncid 0x%x", ncid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
if (!h5)
{
/* If this is a netcdf-3 file, there is only one group, the root
* group, and its vars have ids 0 thru nvars - 1. */
if ((retval = nc_inq(ncid, NULL, &num_vars, NULL, NULL)))
return retval;
if (varids)
for (v = 0; v < num_vars; v++)
varids[v] = v;
}
else
{
/* This is a netCDF-4 group. Round up them doggies and count
* 'em. The list is in correct (i.e. creation) order. */
if (grp->var)
{
for (var = grp->var; var; var = var->next)
{
if (varids)
varids[num_vars] = var->varid;
num_vars++;
}
}
}
/* If the user wants to know how many vars in the group, tell
* him. */
if (nvars)
*nvars = num_vars;
return NC_NOERR;
}
/* This is the comparison function used for sorting dim ids. Integer
comparison: returns negative if b > a and positive if a > b. */
static int
int_cmp(const void *a, const void *b)
{
const int *ia = (const int *)a;
const int *ib = (const int *)b;
return *ia - *ib;
}
/* Find all dimids for a location. This finds all dimensions in a
* group, with or without any of its parents, depending on last
* parameter. */
int
NCD_inq_dimids(int ncid, int *ndims, int *dimids, int include_parents)
{
NC_GRP_INFO_T *grp, *g;
NC_HDF5_FILE_INFO_T *h5;
NC_DIM_INFO_T *dim;
int d, num = 0;
int retval;
LOG((2, "nc_inq_dimids: ncid 0x%x include_parents: %d", ncid,
include_parents));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
if (!h5)
{
/* If this is a netcdf-3 file, then the dimids are going to be 0
* thru ndims-1, so just provide them. */
if ((retval = nc_inq(ncid, &num, NULL, NULL, NULL)))
return retval;
if (dimids)
for (d = 0; d < num; d++)
dimids[d] = d;
}
else
{
/* First count them. */
for (dim = grp->dim; dim; dim = dim->next)
num++;
if (include_parents)
for (g = grp->parent; g; g = g->parent)
for (dim = g->dim; dim; dim = dim->next)
num++;
/* If the user wants the dimension ids, get them. */
if (dimids)
{
int n = 0;
/* Get dimension ids from this group. */
for (dim = grp->dim; dim; dim = dim->next)
dimids[n++] = dim->dimid;
/* Get dimension ids from parent groups. */
if (include_parents)
for (g = grp->parent; g; g = g->parent)
for (dim = g->dim; dim; dim = dim->next)
dimids[n++] = dim->dimid;
qsort(dimids, num, sizeof(int), int_cmp);
}
}
/* If the user wants the number of dims, give it. */
if (ndims)
*ndims = num;
return NC_NOERR;
}

52
libdiskless/ncdinternal.c
View File

@ -1,52 +0,0 @@
/** \file \internal
Internal netcdf-4 functions.
This file contains functions internal to the netcdf4 library. None of
the functions in this file are exposed in the exetnal API. These
functions all relate to the manipulation of netcdf-4's in-memory
buffer of metadata information, i.e. the linked list of NC_FILE_INFO_T
structs.
Copyright 2003-2011, University Corporation for Atmospheric
Research. See the COPYRIGHT file for copying and redistribution
conditions.
*/
#include "config.h"
#include "nc4internal.h"
#include "nc.h" /* from libsrc */
#include "ncdispatch.h" /* from libdispatch */
#include <utf8proc.h>
/** Show the in-memory metadata for a netcdf file. */
int
NCD_show_metadata(int ncid)
{
int retval = NC_NOERR;
#ifdef LOGGING
NC_FILE_INFO_T *nc;
int old_log_level = nc_log_level;
/* Find file metadata. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Log level must be 2 to see metadata. */
nc_log_level = 2;
retval = log_metadata_nc(nc);
nc_log_level = old_log_level;
#endif /*LOGGING*/
return retval;
}
int
NCD_new_nc(NC** ncpp)
{
NC_FILE_INFO_T** ncp;
/* Allocate memory for this info. */
if (!(ncp = calloc(1, sizeof(NC_FILE_INFO_T))))
return NC_ENOMEM;
if(ncpp) *ncpp = (NC*)ncp;
return NC_NOERR;
}

742
libdiskless/ncdtype.c
View File

@ -1,742 +0,0 @@
/*
This file is part of netcdf-4, a netCDF-like interface for HDF5, or a
HDF5 backend for netCDF, depending on your point of view.
This file handles the nc4 user-defined type functions (i.e. compound
and opaque types).
Copyright 2005, University Corporation for Atmospheric Research. See
the COPYRIGHT file for copying and redistribution conditions.
$Id: nc4type.c,v 1.73 2010/05/25 17:54:24 dmh Exp $
*/
#include "nc4internal.h"
#define NUM_ATOMIC_TYPES 13
static char atomic_name[NUM_ATOMIC_TYPES][NC_MAX_NAME + 1] = {"none", "byte", "char",
"short", "int", "float",
"double", "ubyte",
"ushort", "uint",
"int64", "uint64", "string"};
EXTERNL int
NCD_inq_type_equal(int ncid1, nc_type typeid1, int ncid2,
nc_type typeid2, int *equalp)
{
NC_GRP_INFO_T *grp1, *grp2;
NC_TYPE_INFO_T *type1, *type2;
int retval;
LOG((2, "nc_inq_type_equal: ncid1 0x%x typeid1 %d ncid2 0x%x typeid2 %d",
ncid1, typeid1, ncid2, typeid2));
/* Check input. */
if(equalp == NULL) return NC_NOERR;
if (typeid1 <= NC_NAT || typeid2 <= NC_NAT)
return NC_EINVAL;
/* If one is atomic, and the other user-defined, the types are not
* equal. */
if ((typeid1 <= NC_STRING && typeid2 > NC_STRING) ||
(typeid2 <= NC_STRING && typeid1 > NC_STRING))
{
if (equalp) *equalp = 0;
return NC_NOERR;
}
/* If both are atomic types, the answer is easy. */
if (typeid1 <= NUM_ATOMIC_TYPES)
{
if (equalp)
{
if (typeid1 == typeid2)
*equalp = 1;
else
*equalp = 0;
}
return NC_NOERR;
}
/* Not atomic types - so find type1 and type2 information. */
if ((retval = nc4_find_nc4_grp(ncid1, &grp1)))
return retval;
if (!(type1 = nc4_rec_find_nc_type(grp1->file->nc4_info->root_grp,
typeid1)))
return NC_EBADTYPE;
if ((retval = nc4_find_nc4_grp(ncid2, &grp2)))
return retval;
if (!(type2 = nc4_rec_find_nc_type(grp2->file->nc4_info->root_grp,
typeid2)))
return NC_EBADTYPE;
/* Are the two types equal? */
if (equalp)
*equalp = (int)H5Tequal(type1->native_typeid, type2->native_typeid);
return NC_NOERR;
}
/* Get the id of a type from the name. */
EXTERNL int
NCD_inq_typeid(int ncid, const char *name, nc_type *typeidp)
{
NC_GRP_INFO_T *grp, *grp2;
NC_HDF5_FILE_INFO_T *h5;
NC_TYPE_INFO_T *type = NULL;
char *norm_name;
int i, retval;
for (i = 0; i < NUM_ATOMIC_TYPES; i++)
if (!strcmp(name, atomic_name[i]))
{
if (typeidp)
*typeidp = i;
return NC_NOERR;
}
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* Must be a netCDF-4 file. */
if (!h5)
return NC_ENOTNC4;
/* If the first char is a /, this is a fully-qualified
* name. Otherwise, this had better be a local name (i.e. no / in
* the middle). */
if (name[0] != '/' && strstr(name, "/"))
return NC_EINVAL;
/* Normalize name. */
if (!(norm_name = malloc(strlen(name) + 1)))
return NC_ENOMEM;
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Is the type in this group? If not, search parents. */
for (grp2 = grp; grp2; grp2 = grp2->parent)
for (type = grp2->type; type; type = type->next)
if (!strcmp(norm_name, type->name))
{
if (typeidp)
*typeidp = type->nc_typeid;
break;
}
/* Still didn't find type? Search file recursively, starting at the
* root group. */
if (!type)
if ((type = nc4_rec_find_named_type(grp->file->nc4_info->root_grp, norm_name)))
if (typeidp)
*typeidp = type->nc_typeid;
free(norm_name);
/* OK, I give up already! */
if (!type)
return NC_EBADTYPE;
return NC_NOERR;
}
/* Find all user-defined types for a location. This finds all
* user-defined types in a group. */
int
NCD_inq_typeids(int ncid, int *ntypes, int *typeids)
{
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_TYPE_INFO_T *type;
int num = 0;
int retval;
LOG((2, "nc_inq_typeids: ncid 0x%x", ncid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* If this is a netCDF-4 file, count types. */
if (h5 && grp->type)
for (type = grp->type; type; type = type->next)
{
if (typeids)
typeids[num] = type->nc_typeid;
num++;
}
/* Give the count to the user. */
if (ntypes)
*ntypes = num;
return NC_NOERR;
}
/* This internal function adds a new user defined type to the metadata
* of a group of an open file. */
static int
add_user_type(int ncid, size_t size, const char *name, nc_type base_typeid,
nc_type type_class, nc_type *typeidp)
{
NC_HDF5_FILE_INFO_T *h5;
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
char norm_name[NC_MAX_NAME + 1];
int retval;
/* Check and normalize the name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
LOG((2, "add_user_type: ncid 0x%x size %d name %s base_typeid %d ",
ncid, size, norm_name, base_typeid));
/* Find group metadata. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
/* Only netcdf-4 files! */
if (!h5)
return NC_ENOTNC4;
/* Turn on define mode if it is not on. */
if (!(h5->cmode & NC_INDEF))
if ((retval = nc_redef(ncid)))
return retval;
/* No size is provided for vlens or enums, get it from the base type. */
if (type_class == NC_VLEN || type_class == NC_ENUM)
{
if ((retval = nc4_get_typelen_mem(grp->file->nc4_info, base_typeid, 0,
&size)))
return retval;
}
else if (size <= 0)
return NC_EINVAL;
/* Check that this name is not in use as a var, grp, or type. */
if ((retval = nc4_check_dup_name(grp, norm_name)))
return retval;
/* Add to our list of types. */
if ((retval = nc4_type_list_add(&(grp->type), &type)))
return retval;
/* Remember info about this type. */
type->nc_typeid = grp->file->nc4_info->next_typeid++;
type->size = size;
if (!(type->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(type->name, norm_name);
type->class = type_class;
type->base_nc_type = base_typeid;
/* Return the typeid to the user. */
if (typeidp)
*typeidp = type->nc_typeid;
return NC_NOERR;
}
/* The sizes of types may vary from platform to platform, but within
* netCDF files, type sizes are fixed. */
#define NC_CHAR_LEN sizeof(char)
#define NC_STRING_LEN sizeof(char *)
#define NC_BYTE_LEN 1
#define NC_SHORT_LEN 2
#define NC_INT_LEN 4
#define NC_FLOAT_LEN 4
#define NC_DOUBLE_LEN 8
#define NC_INT64_LEN 8
/* Get the name and size of a type. For strings, 1 is returned. For
* VLEN the base type len is returned. */
int
NCD_inq_type(int ncid, nc_type typeid, char *name, size_t *size)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
int atomic_size[NUM_ATOMIC_TYPES] = {0, NC_BYTE_LEN, NC_CHAR_LEN, NC_SHORT_LEN,
NC_INT_LEN, NC_FLOAT_LEN, NC_DOUBLE_LEN,
NC_BYTE_LEN, NC_SHORT_LEN, NC_INT_LEN, NC_INT64_LEN,
NC_INT64_LEN, NC_STRING_LEN};
int retval;
LOG((2, "nc_inq_type: ncid 0x%x typeid %d", ncid, typeid));
/* If this is an atomic type, the answer is easy. */
if (typeid <= NUM_ATOMIC_TYPES)
{
if (name)
strcpy(name, atomic_name[typeid]);
if (size)
*size = atomic_size[typeid];
return NC_NOERR;
}
/* Not an atomic type - so find group. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find this type. */
if (!(type = nc4_rec_find_nc_type(grp->file->nc4_info->root_grp, typeid)))
return NC_EBADTYPE;
if (name)
strcpy(name, type->name);
if (size)
{
if (type->class != NC_VLEN)
*size = type->size;
else
*size = sizeof(nc_vlen_t);
}
return NC_NOERR;
}
/* Create a compound type. */
int
NCD_def_compound(int ncid, size_t size, const char *name, nc_type *typeidp)
{
return add_user_type(ncid, size, name, 0, NC_COMPOUND, typeidp);
}
/* Insert a named field into a compound type. */
int
NCD_insert_compound(int ncid, nc_type typeid, const char *name, size_t offset,
nc_type field_typeid)
{
return nc_insert_array_compound(ncid, typeid, name, offset,
field_typeid, 0, NULL);
}
/* Insert a named array into a compound type. */
EXTERNL int
NCD_insert_array_compound(int ncid, int typeid, const char *name,
size_t offset, nc_type field_typeid,
int ndims, const int *dim_sizesp)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
char norm_name[NC_MAX_NAME + 1];
int retval;
LOG((2, "nc_insert_array_compound: ncid 0x%x, typeid %d name %s "
"offset %d field_typeid %d ndims %d", ncid, typeid,
name, offset, field_typeid, ndims));
/* Check and normalize the name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* Find file metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find type metadata. */
if ((retval = nc4_find_type(grp->file->nc4_info, typeid, &type)))
return retval;
/* Did the user give us a good compound type typeid? */
if (!type || type->class != NC_COMPOUND)
return NC_EBADTYPE;
/* If this type has already been written to the file, you can't
* change it. */
if (type->committed)
return NC_ETYPDEFINED;
/* Insert new field into this type's list of fields. */
if ((retval = nc4_field_list_add(&type->field, type->num_fields,
norm_name, offset, 0, 0, field_typeid,
ndims, dim_sizesp)))
return retval;
type->num_fields++;
return NC_NOERR;
}
/* Find info about any user defined type. */
int
NCD_inq_user_type(int ncid, nc_type typeid, char *name, size_t *size,
nc_type *base_nc_typep, size_t *nfieldsp, int *classp)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
NC_FIELD_INFO_T *field;
int retval;
LOG((2, "nc_inq_user_type: ncid 0x%x typeid %d", ncid, typeid));
/* Find group metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find this type. */
if (!(type = nc4_rec_find_nc_type(grp->file->nc4_info->root_grp, typeid)))
return NC_EBADTYPE;
/* Count the number of fields. */
if (nfieldsp)
{
*nfieldsp = 0;
if (type->class == NC_COMPOUND)
for (field = type->field; field; field = field->next)
(*nfieldsp)++;
else if (type->class == NC_ENUM)
*nfieldsp = type->num_enum_members;
}
/* Fill in size and name info, if desired. */
if (size)
{
if (type->class != NC_VLEN)
*size = type->size;
else
*size = sizeof(nc_vlen_t);
}
if (name)
strcpy(name, type->name);
/* VLENS and ENUMs have a base type - that is, they type they are
* arrays of or enums of. */
if (base_nc_typep)
*base_nc_typep = type->base_nc_type;
/* If the user wants it, tell whether this is a compound, opaque,
* vlen, enum, or string class of type. */
if (classp)
*classp = type->class;
return NC_NOERR;
}
/* Given the ncid, typeid and fieldid, get info about the field. */
int
NCD_inq_compound_field(int ncid, nc_type typeid, int fieldid, char *name,
size_t *offsetp, nc_type *field_typeidp, int *ndimsp,
int *dim_sizesp)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
NC_FIELD_INFO_T *field;
int d, retval;
/* Find file metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find this type. */
if (!(type = nc4_rec_find_nc_type(grp->file->nc4_info->root_grp, typeid)))
return NC_EBADTYPE;
/* Find the field. */
for (field = type->field; field; field = field->next)
if (field->fieldid == fieldid)
{
if (name)
strcpy(name, field->name);
if (offsetp)
*offsetp = field->offset;
if (field_typeidp)
*field_typeidp = field->nctype;
if (ndimsp)
*ndimsp = field->ndims;
if (dim_sizesp)
for (d = 0; d < field->ndims; d++)
dim_sizesp[d] = field->dim_size[d];
return NC_NOERR;
}
return NC_EBADFIELD;
}
/* Find a netcdf-4 file. THis will return an error if it finds a
* netcdf-3 file, or a netcdf-4 file with strict nc3 rules. */
static int
find_nc4_file(int ncid, NC_FILE_INFO_T **nc)
{
/* Find file metadata. */
if (!((*nc) = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Check for netcdf-3 files or netcdf-3 rules. */
if (!(*nc)->nc4_info)
return NC_ENOTNC4;
if ((*nc)->nc4_info->cmode & NC_CLASSIC_MODEL)
return NC_ESTRICTNC3;
return NC_NOERR;
}
/* Given the typeid and the name, get the fieldid. */
int
NCD_inq_compound_fieldindex(int ncid, nc_type typeid, const char *name, int *fieldidp)
{
NC_FILE_INFO_T *nc;
NC_TYPE_INFO_T *type;
NC_FIELD_INFO_T *field;
char norm_name[NC_MAX_NAME + 1];
int retval;
LOG((2, "nc_inq_compound_fieldindex: ncid 0x%x typeid %d name %s",
ncid, typeid, name));
/* Find file metadata. */
if ((retval = find_nc4_file(ncid, &nc)))
return retval;
/* Find the type. */
if ((retval = nc4_find_type(nc->nc4_info, typeid, &type)))
return retval;
/* Did the user give us a good compound type typeid? */
if (!type || type->class != NC_COMPOUND)
return NC_EBADTYPE;
/* Normalize name. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Find the field with this name. */
for (field = type->field; field; field = field->next)
if (!strcmp(field->name, norm_name))
break;
if (!field)
return NC_EBADFIELD;
if (fieldidp)
*fieldidp = field->fieldid;
return NC_NOERR;
}
/* Opaque type. */
/* Create an opaque type. Provide a size and a name. */
int
NCD_def_opaque(int ncid, size_t datum_size, const char *name,
nc_type *typeidp)
{
return add_user_type(ncid, datum_size, name, 0, NC_OPAQUE, typeidp);
}
/* Define a variable length type. */
int
NCD_def_vlen(int ncid, const char *name, nc_type base_typeid,
nc_type *typeidp)
{
return add_user_type(ncid, 0, name, base_typeid, NC_VLEN, typeidp);
}
/* Create an enum type. Provide a base type and a name. At the moment
* only ints are accepted as base types. */
int
NCD_def_enum(int ncid, nc_type base_typeid, const char *name,
nc_type *typeidp)
{
return add_user_type(ncid, 0, name, base_typeid, NC_ENUM, typeidp);
}
/* Get enum name from enum value. Name size will be <= NC_MAX_NAME. */
int
NCD_inq_enum_ident(int ncid, nc_type xtype, long long value, char *identifier)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
NC_ENUM_MEMBER_INFO_T *enum_member;
long long ll_val;
int i;
int retval;
LOG((3, "nc_inq_enum_ident: xtype %d value %d\n", xtype, value));
/* Find group metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find this type. */
if (!(type = nc4_rec_find_nc_type(grp->file->nc4_info->root_grp, xtype)))
return NC_EBADTYPE;
/* Complain if they are confused about the type. */
if (type->class != NC_ENUM)
return NC_EBADTYPE;
/* Move to the desired enum member in the list. */
enum_member = type->enum_member;
for (i = 0; i < type->num_enum_members; i++)
{
switch (type->base_nc_type)
{
case NC_BYTE:
ll_val = *(char *)enum_member->value;
break;
case NC_UBYTE:
ll_val = *(unsigned char *)enum_member->value;
break;
case NC_SHORT:
ll_val = *(short *)enum_member->value;
break;
case NC_USHORT:
ll_val = *(unsigned short *)enum_member->value;
break;
case NC_INT:
ll_val = *(int *)enum_member->value;
break;
case NC_UINT:
ll_val = *(unsigned int *)enum_member->value;
break;
case NC_INT64:
case NC_UINT64:
ll_val = *(long long *)enum_member->value;
break;
default:
return NC_EINVAL;
}
LOG((4, "ll_val=%d", ll_val));
if (ll_val == value)
{
if (identifier)
strcpy(identifier, enum_member->name);
break;
}
else
enum_member = enum_member->next;
}
/* If we didn't find it, life sucks for us. :-( */
if (i == type->num_enum_members)
return NC_EINVAL;
return NC_NOERR;
}
/* Get information about an enum member: an identifier and
* value. Identifier size will be <= NC_MAX_NAME. */
int
NCD_inq_enum_member(int ncid, nc_type typeid, int idx, char *identifier,
void *value)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
NC_ENUM_MEMBER_INFO_T *enum_member;
int i;
int retval;
LOG((2, "nc_inq_enum_member: ncid 0x%x typeid %d", ncid, typeid));
/* Find group metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find this type. */
if (!(type = nc4_rec_find_nc_type(grp->file->nc4_info->root_grp, typeid)))
return NC_EBADTYPE;
/* Complain if they are confused about the type. */
if (type->class != NC_ENUM)
return NC_EBADTYPE;
/* Check index. */
if (idx >= type->num_enum_members)
return NC_EINVAL;
/* Move to the desired enum member in the list. */
enum_member = type->enum_member;
for (i = 0; i < idx; i++)
enum_member = enum_member->next;
/* Give the people what they want. */
if (identifier)
strcpy(identifier, enum_member->name);
if (value)
memcpy(value, enum_member->value, type->size);
return NC_NOERR;
}
/* Insert a identifierd value into an enum type. The value must fit within
* the size of the enum type, the identifier size must be <= NC_MAX_NAME. */
int
NCD_insert_enum(int ncid, nc_type typeid, const char *identifier,
const void *value)
{
NC_GRP_INFO_T *grp;
NC_TYPE_INFO_T *type;
char norm_name[NC_MAX_NAME + 1];
int retval;
LOG((2, "nc_insert_enum: ncid 0x%x, typeid %d identifier %s value %d", ncid,
typeid, identifier, value));
/* Check and normalize the name. */
if ((retval = nc4_check_name(identifier, norm_name)))
return retval;
/* Find file metadata. */
if ((retval = nc4_find_nc4_grp(ncid, &grp)))
return retval;
/* Find type metadata. */
if ((retval = nc4_find_type(grp->file->nc4_info, typeid, &type)))
return retval;
/* Did the user give us a good enum typeid? */
if (!type || type->class != NC_ENUM)
return NC_EBADTYPE;
/* If this type has already been written to the file, you can't
* change it. */
if (type->committed)
return NC_ETYPDEFINED;
/* Insert new field into this type's list of fields. */
if ((retval = nc4_enum_member_add(&type->enum_member, type->size,
norm_name, value)))
return retval;
type->num_enum_members++;
return NC_NOERR;
}
/* Insert one element into an already allocated vlen array element. */
int
NCD_put_vlen_element(int ncid, int typeid, void *vlen_element,
size_t len, const void *data)
{
nc_vlen_t *tmp = vlen_element;
tmp->len = len;
tmp->p = (void *)data;
return NC_NOERR;
}
/* Insert one element into an already allocated vlen array element. */
int
NCD_get_vlen_element(int ncid, int typeid, const void *vlen_element,
size_t *len, void *data)
{
const nc_vlen_t *tmp = vlen_element;
int type_size = 4;
*len = tmp->len;
memcpy(data, tmp->p, tmp->len * type_size);
return NC_NOERR;
}

817
libdiskless/ncdvar.c
View File

@ -1,817 +0,0 @@
/* \file \internal
Variables for the diskless API.
Copyright 2011, University Corporation for Atmospheric Research. See
COPYRIGHT file for copying and redistribution conditions.
*/
#include <nc4internal.h>
#include "ncddispatch.h"
#include <math.h>
/* Min and max deflate levels tolerated by HDF5. */
#define MIN_DEFLATE_LEVEL 0
#define MAX_DEFLATE_LEVEL 9
/* This is to track opened HDF5 objects to make sure they are
* closed. */
#ifdef EXTRA_TESTS
extern int num_plists;
#endif /* EXTRA_TESTS */
/* One meg is the minimum buffer size. */
#define ONE_MEG 1048576
/* Szip options. */
#define NC_SZIP_EC_OPTION_MASK 4
#define NC_SZIP_NN_OPTION_MASK 32
#define NC_SZIP_MAX_PIXELS_PER_BLOCK 32
int nc4_get_default_fill_value(NC_TYPE_INFO_T *type_info, void *fill_value);
/* Set chunk cache size for a variable. */
int
NCD_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
float preemption)
{
return NC_EINVAL;
}
/* Get chunk cache size for a variable. */
int
NCD_get_var_chunk_cache(int ncid, int varid, size_t *sizep,
size_t *nelemsp, float *preemptionp)
{
return NC_EINVAL;
}
/* Create a new variable to hold user data. This is what it's all
* about baby! */
int
NCD_def_var(int ncid, const char *name, nc_type xtype, int ndims,
const int *dimidsp, int *varidp)
{
NC_FILE_INFO_T *nc;
LOG((2, "NCD_def_var: ncid 0x%x name %s xtype %d ndims %d",
ncid, name, xtype, ndims));
/* If there are dimensions, I need their ids. */
if (ndims && !dimidsp)
return NC_EINVAL;
/* Find metadata for this file. */
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Netcdf-3 cases handled by dispatch layer. */
assert(nc->nc4_info);
/* Handle netcdf-4 cases. */
{
NC_GRP_INFO_T *grp;
NC_VAR_INFO_T *var;
NC_DIM_INFO_T *dim;
NC_HDF5_FILE_INFO_T *h5;
NC_TYPE_INFO_T *type_info;
char norm_name[NC_MAX_NAME + 1];
int new_varid = 0;
int num_unlim = 0;
int d;
size_t num_values = 1;
int retval;
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
return retval;
assert(grp && h5);
/* If it's not in define mode, strict nc3 files error out,
* otherwise switch to define mode. */
if (!(h5->flags & NC_INDEF))
{
if (h5->cmode & NC_CLASSIC_MODEL)
return NC_ENOTINDEFINE;
if ((retval = NCD_redef(ncid)))
return retval;
}
/* Check and normalize the name. */
if ((retval = nc4_check_name(name, norm_name)))
return retval;
/* Not a Type is, well, not a type.*/
if (xtype == NC_NAT)
return NC_EBADTYPE;
/* For classic files, only classic types are allowed. */
if (h5->cmode & NC_CLASSIC_MODEL && xtype > NC_DOUBLE)
return NC_ESTRICTNC3;
/* If this is a user defined type, find it. */
if (xtype > NC_STRING)
if ((retval = nc4_find_type(grp->file->nc4_info, xtype, &type_info)))
return NC_EBADTYPE;
/* cast needed for braindead systems with signed size_t */
if((unsigned long) ndims > X_INT_MAX) /* Backward compat */
return NC_EINVAL;
/* Classic model files have a limit on number of vars. */
if(h5->cmode & NC_CLASSIC_MODEL && h5->nvars >= NC_MAX_VARS)
return NC_EMAXVARS;
/* Check that this name is not in use as a var, grp, or type. */
if ((retval = nc4_check_dup_name(grp, norm_name)))
return retval;
/* Get the new varid. */
for (var = grp->var; var; var = var->next)
new_varid++;
/* Check all the dimids to make sure they exist. */
for (d = 0; d < ndims; d++)
{
if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, NULL)))
return retval;
if (dim->unlimited)
num_unlim++;
else
num_values *= dim->len;
}
/* These degrubbing messages sure are handy! */
LOG((3, "nc_def_var_nc4: name %s type %d ndims %d", norm_name, xtype, ndims));
#ifdef LOGGING
{
int dd;
for (dd = 0; dd < ndims; dd++)
LOG((4, "dimid[%d] %d", dd, dimidsp[dd]));
}
#endif
/* Add the var to the end of the list. */
if ((retval = nc4_var_list_add(&grp->var, &var)))
return retval;
/* Now fill in the values in the var info structure. */
if (!(var->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(var->name, norm_name);
var->varid = grp->nvars++;
var->xtype = xtype;
var->ndims = ndims;
var->dirty++;
/* If this is a user-defined type, there is a type_info stuct with
* all the type information. For atomic types, fake up a type_info
* struct. */
if (xtype > NC_STRING)
var->type_info = type_info;
else
{
if (!(var->type_info = calloc(1, sizeof(NC_TYPE_INFO_T))))
return NC_ENOMEM;
var->type_info->nc_typeid = xtype;
if ((retval = nc4_get_hdf_typeid(h5, var->xtype, &var->type_info->hdf_typeid,
var->type_info->endianness)))
return retval;
if ((var->type_info->native_typeid = H5Tget_native_type(var->type_info->hdf_typeid,
H5T_DIR_DEFAULT)) < 0)
return NC_EHDFERR;
if ((retval = nc4_get_typelen_mem(h5, var->type_info->nc_typeid, 0,
&var->type_info->size)))
return retval;
}
if (!num_unlim)
var->contiguous = 1;
/* Allocate space for dimension information. */
if (ndims)
{
if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *))))
return NC_ENOMEM;
if (!(var->dimids = calloc(ndims, sizeof(int))))
return NC_ENOMEM;
}
/* Allocate space for the data. */
if (!(var->diskless_data = malloc(num_values * var->type_info->size)))
return NC_ENOMEM;
/* At the same time, check to see if this is a coordinate
* variable. If so, it will have the same name as one of its
* dimensions. If it is a coordinate var, is it a coordinate var in
* the same group as the dim? */
for (d = 0; d < ndims; d++)
{
NC_GRP_INFO_T *dim_grp;
if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, &dim_grp)))
return retval;
if (strcmp(dim->name, norm_name) == 0 && dim_grp == grp && d == 0)
{
var->dimscale++;
dim->coord_var = var;
dim->coord_var_in_grp++;
}
var->dimids[d] = dimidsp[d];
var->dim[d] = dim;
}
/* If the user names this variable the same as a dimension, but
* doesn't use that dimension first in its list of dimension ids,
* is not a coordinate variable. I need to change its HDF5 name,
* because the dimension will cause a HDF5 dataset to be created,
* and this var has the same name. */
for (dim = grp->dim; dim; dim = dim->next)
if (!strcmp(dim->name, norm_name) &&
(!var->ndims || dimidsp[0] != dim->dimid))
{
/* Set a different hdf5 name for this variable to avoid name
* clash. */
if (strlen(norm_name) + strlen(NON_COORD_PREPEND) > NC_MAX_NAME)
return NC_EMAXNAME;
if (!(var->hdf5_name = malloc((strlen(NON_COORD_PREPEND) +
strlen(norm_name) + 1) * sizeof(char))))
return NC_ENOMEM;
sprintf(var->hdf5_name, "%s%s", NON_COORD_PREPEND, norm_name);
}
/* If this is a coordinate var, it is marked as a HDF5 dimension
* scale. (We found dim above.) Otherwise, allocate space to
* remember whether dimension scales have been attached to each
* dimension. */
if (!var->dimscale && ndims)
if (ndims && !(var->dimscale_attached = calloc(ndims, sizeof(int))))
return NC_ENOMEM;
/* Return the varid. */
if (varidp)
*varidp = var->varid;
LOG((4, "new varid %d", var->varid));
}
return NC_NOERR;
}
/* Get all the information about a variable. Pass NULL for whatever
* you don't care about. This is an internal function, not exposed to
* the user. */
int
NCD_inq_var_all(int ncid, int varid, char *name, nc_type *xtypep,
int *ndimsp, int *dimidsp, int *nattsp,
int *shufflep, int *deflatep, int *deflate_levelp,
int *fletcher32p, int *contiguousp, size_t *chunksizesp,
int *no_fill, void *fill_valuep, int *endiannessp,
int *options_maskp, int *pixels_per_blockp)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
NC_ATT_INFO_T *att;
int natts=0;
size_t type_size;
int d;
int retval;
LOG((2, "nc_inq_var_all: ncid 0x%x varid %d", ncid, varid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
assert(nc && grp && h5);
/* Walk through the list of vars, and return the info about the one
with a matching varid. If the varid is -1, find the global
atts and call it a day. */
if (varid == NC_GLOBAL)
{
if (nattsp)
{
for (att = grp->att; att; att = att->next)
natts++;
*nattsp = natts;
}
return NC_NOERR;
}
/* Find the var. */
for (var = grp->var; var; var = var->next)
if (var->varid == varid)
break;
/* Oh no! Maybe we couldn't find it (*sob*)! */
if (!var)
return NC_ENOTVAR;
/* Copy the data to the user's data buffers. */
if (name)
strcpy(name, var->name);
if (xtypep)
*xtypep = var->xtype;
if (ndimsp)
*ndimsp = var->ndims;
if (dimidsp)
for (d = 0; d < var->ndims; d++)
dimidsp[d] = var->dimids[d];
if (nattsp)
{
for (att = var->att; att; att = att->next)
natts++;
*nattsp = natts;
}
/* Chunking stuff. */
if (!var->contiguous && chunksizesp)
for (d = 0; d < var->ndims; d++)
{
chunksizesp[d] = var->chunksizes[d];
LOG((4, "chunksizesp[%d]=%d", d, chunksizesp[d]));
}
if (contiguousp)
*contiguousp = var->contiguous ? NC_CONTIGUOUS : NC_CHUNKED;
/* Filter stuff. */
if (deflatep)
*deflatep = var->deflate;
if (deflate_levelp)
*deflate_levelp = var->deflate_level;
if (shufflep)
*shufflep = var->shuffle;
if (fletcher32p)
*fletcher32p = var->fletcher32;
if (options_maskp)
*options_maskp = var->options_mask;
if (pixels_per_blockp)
*pixels_per_blockp = var->pixels_per_block;
/* Fill value stuff. */
if (no_fill)
*no_fill = var->no_fill;
/* Don't do a thing with fill_valuep if no_fill mode is set for
* this var, or if fill_valuep is NULL. */
if (!var->no_fill && fill_valuep)
{
/* Do we have a fill value for this var? */
if (var->fill_value)
{
if ((retval = nc4_get_typelen_mem(grp->file->nc4_info, var->xtype, 0, &type_size)))
return retval;
memcpy(fill_valuep, var->fill_value, type_size);
}
else
{
if ((retval = nc4_get_default_fill_value(var->type_info, fill_valuep)))
return retval;
}
}
/* Does the user want the endianness of this variable? */
if (endiannessp)
*endiannessp = var->type_info->endianness;
return NC_NOERR;
}
/* This functions sets extra stuff about a netCDF-4 variable which
must be set before the enddef but after the def_var. This is an
internal function, deliberately hidden from the user so that we can
change the prototype of this functions without changing the API. */
static int
nc_def_var_extra(int ncid, int varid, int *shuffle, int *deflate,
int *deflate_level, int *fletcher32, int *contiguous,
const size_t *chunksizes, int *no_fill,
const void *fill_value, int *endianness,
int *options_mask, int *pixels_per_block)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
NC_DIM_INFO_T *dim;
size_t type_size;
int d;
int retval;
LOG((2, "nc_def_var_extra: ncid 0x%x varid %d", ncid, varid));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Attempting to do any of these things on a netCDF-3 file produces
* an error. */
if (!h5)
return NC_ENOTNC4;
assert(nc && grp && h5);
/* Find the var. */
for (var = grp->var; var; var = var->next)
if (var->varid == varid)
break;
/* Oh no! Maybe we couldn't find it (*sob*)! */
if (!var)
return NC_ENOTVAR;
/* Can't turn on contiguous and deflate/fletcher32/szip. */
if (contiguous)
if ((*contiguous != NC_CHUNKED && deflate) ||
(*contiguous != NC_CHUNKED && fletcher32) ||
(*contiguous != NC_CHUNKED && options_mask))
return NC_EINVAL;
/* If the HDF5 dataset has already been created, then it is too
* late to set all the extra stuff. */
if (var->created)
return NC_ELATEDEF;
/* Check compression options. */
if ((deflate && options_mask) ||
(deflate && !deflate_level) ||
(options_mask && !pixels_per_block))
return NC_EINVAL;
/* Valid deflate level? */
if (deflate && deflate_level)
{
if (*deflate)
if (*deflate_level < MIN_DEFLATE_LEVEL ||
*deflate_level > MAX_DEFLATE_LEVEL)
return NC_EINVAL;
if (var->options_mask)
return NC_EINVAL;
/* For scalars, just ignore attempt to deflate. */
if (!var->ndims)
return NC_NOERR;
/* Well, if we couldn't find any errors, I guess we have to take
* the users settings. Darn! */
var->contiguous = 0;
var->deflate = *deflate;
if (*deflate)
var->deflate_level = *deflate_level;
LOG((3, "nc_def_var_extra: *deflate_level %d", *deflate_level));
}
/* Szip in use? */
if (options_mask)
{
#ifndef USE_SZIP
return NC_EINVAL;
#endif
if (var->deflate)
return NC_EINVAL;
if ((*options_mask != NC_SZIP_EC_OPTION_MASK) &&
(*options_mask != NC_SZIP_NN_OPTION_MASK))
return NC_EINVAL;
if ((*pixels_per_block > NC_SZIP_MAX_PIXELS_PER_BLOCK) ||
(var->type_info->nc_typeid >= NC_STRING))
return NC_EINVAL;
var->options_mask = *options_mask;
var->pixels_per_block = *pixels_per_block;
var->contiguous = 0;
}
/* Shuffle filter? */
if (shuffle)
{
var->shuffle = *shuffle;
var->contiguous = 0;
}
/* Fltcher32 checksum error protection? */
if (fletcher32)
{
var->fletcher32 = *fletcher32;
var->contiguous = 0;
}
/* Does the user want a contiguous dataset? Not so fast! Make sure
* that there are no unlimited dimensions, and no filters in use
* for this data. */
if (contiguous && *contiguous)
{
if (var->deflate || var->fletcher32 || var->shuffle || var->options_mask)
return NC_EINVAL;
for (d = 0; d < var->ndims; d++)
{
if ((retval = nc4_find_dim(grp, var->dimids[d], &dim, NULL)))
return retval;
if (dim->unlimited)
return NC_EINVAL;
}
var->contiguous = NC_CONTIGUOUS;
}
/* Chunksizes anyone? */
if (contiguous && *contiguous == NC_CHUNKED)
{
var->contiguous = 0;
}
/* Are we setting a fill modes? */
if (no_fill)
{
if (*no_fill)
var->no_fill = 1;
else
var->no_fill = 0;
}
/* Are we setting a fill value? */
if (fill_value && !var->no_fill)
{
/* If fill value hasn't been set, allocate space. */
if ((retval = nc4_get_typelen_mem(h5, var->xtype, 0, &type_size)))
return retval;
if (!var->fill_value)
if (!(var->fill_value = malloc(type_size)))
return NC_ENOMEM;
/* Copy the fill_value. */
LOG((4, "Copying fill value into metadata for variable %s",
var->name));
memcpy(var->fill_value, fill_value, type_size);
/* If there's a _FillValue attribute, delete it. */
retval = nc_del_att(ncid, varid, _FillValue);
if (retval && retval != NC_ENOTATT)
return retval;
/* Create a _FillValue attribute. */
if ((retval = nc_put_att(ncid, varid, _FillValue, var->xtype, 1, fill_value)))
return retval;
}
/* Is the user setting the endianness? */
if (endianness)
var->type_info->endianness = *endianness;
return NC_NOERR;
}
/* Set the deflate level for a var, lower is faster, higher is
* better. Must be called after nc_def_var and before nc_enddef or any
* functions which writes data to the file. */
int
NCD_def_var_deflate(int ncid, int varid, int shuffle, int deflate,
int deflate_level)
{
return nc_def_var_extra(ncid, varid, &shuffle, &deflate,
&deflate_level, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
/* Set checksum for a var. This must be called after the nc_def_var
* but before the nc_enddef. */
int
NCD_def_var_fletcher32(int ncid, int varid, int fletcher32)
{
return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, &fletcher32,
NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
/* Define chunking stuff for a var. This must be done after nc_def_var
and before nc_enddef.
Chunking is required in any dataset with one or more unlimited
dimension in HDF5, or any dataset using a filter.
Where chunksize is a pointer to an array of size ndims, with the
chunksize in each dimension.
*/
int
NCD_def_var_chunking(int ncid, int varid, int contiguous, const size_t *chunksizesp)
{
return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL,
&contiguous, chunksizesp, NULL, NULL, NULL, NULL, NULL);
}
/* Define fill value behavior for a variable. This must be done after
nc_def_var and before nc_enddef. */
int
NCD_def_var_fill(int ncid, int varid, int no_fill, const void *fill_value)
{
return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
NULL, &no_fill, fill_value, NULL, NULL, NULL);
}
/* Define the endianness of a variable. */
int
NCD_def_var_endian(int ncid, int varid, int endianness)
{
return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, &endianness, NULL, NULL);
}
/* Get var id from name. */
int
NCD_inq_varid(int ncid, const char *name, int *varidp)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
char norm_name[NC_MAX_NAME + 1];
int retval;
if (!name)
return NC_EINVAL;
if (!varidp)
return NC_NOERR;
LOG((2, "nc_inq_varid: ncid 0x%x name %s", ncid, name));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Handle netcdf-3. */
assert(h5);
/* Normalize name. */
if ((retval = nc4_normalize_name(name, norm_name)))
return retval;
/* Find var of this name. */
for (var = grp->var; var; var = var->next)
if (!(strcmp(var->name, norm_name)))
{
*varidp = var->varid;
return NC_NOERR;
}
return NC_ENOTVAR;
}
/* Rename a var to "bubba," for example.
According to the netcdf-3.5 docs: If the new name is longer than
the old name, the netCDF dataset must be in define mode. */
int
NCD_rename_var(int ncid, int varid, const char *name)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_HDF5_FILE_INFO_T *h5;
NC_VAR_INFO_T *var;
int retval = NC_NOERR;
LOG((2, "nc_rename_var: ncid 0x%x varid %d name %s",
ncid, varid, name));
/* Find info for this file and group, and set pointer to each. */
if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
return retval;
/* Take care of netcdf-3 files. */
assert(h5);
/* Is the new name too long? */
if (strlen(name) > NC_MAX_NAME)
return NC_EMAXNAME;
/* Trying to write to a read-only file? No way, Jose! */
if (h5->no_write)
return NC_EPERM;
/* Check name validity, if strict nc3 rules are in effect for this
* file. */
if ((retval = NC_check_name(name)))
return retval;
/* Is name in use? */
for (var = grp->var; var; var = var->next)
if (!strncmp(var->name, name, NC_MAX_NAME))
return NC_ENAMEINUSE;
/* Find the var. */
for (var = grp->var; var; var = var->next)
if (var->varid == varid)
break;
if (!var)
return NC_ENOTVAR;
/* If we're not in define mode, new name must be of equal or
less size, if strict nc3 rules are in effect for this . */
if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(var->name) &&
(h5->cmode & NC_CLASSIC_MODEL))
return NC_ENOTINDEFINE;
/* Change the HDF5 file, if this var has already been created
there. */
if (var->created)
{
if (H5Gmove(grp->hdf_grpid, var->name, name) < 0)
BAIL(NC_EHDFERR);
}
/* Now change the name in our metadata. */
free(var->name);
if (!(var->name = malloc((strlen(name) + 1) * sizeof(char))))
return NC_ENOMEM;
strcpy(var->name, name);
exit:
return retval;
}
int
NCD_var_par_access(int ncid, int varid, int par_access)
{
return NC_ENOPAR;
}
int
NCD_put_vara(int ncid, int varid, const size_t *startp,
const size_t *countp, const void *op, int memtype)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_VAR_INFO_T *var;
void *copy_point = NULL;
size_t num_values = 1, num_values_to_start = 0;
int d, retval;
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
assert(nc->nc4_info);
/* Find our metadata for this file, group, and var. */
assert(nc);
if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
return retval;
assert(grp && nc->nc4_info && var && var->name);
/* Where do I start? */
if (var->ndims)
{
num_values_to_start = 1;
for (d = 0; d < var->ndims; d++)
num_values_to_start *= (startp[d] * var->dim[d]->len);
}
copy_point = (void *)((char *)var->diskless_data +
num_values_to_start * var->type_info->size);
/* How many values do I copy? */
if (var->ndims)
for (d = 0; d < var->ndims; d++)
num_values *= countp[d];
/* Copy the data to memory. */
memcpy(copy_point, op,
num_values * var->type_info->size);
return NC_NOERR;
}
/** \internal Read an array of values from a diskless file. */
int
NCD_get_vara(int ncid, int varid, const size_t *startp,
const size_t *countp, void *ip, int memtype)
{
NC_FILE_INFO_T *nc;
NC_GRP_INFO_T *grp;
NC_VAR_INFO_T *var;
void *copy_point = NULL;
size_t num_values = 1, num_values_to_start = 0;
int d, retval;
if (!(nc = nc4_find_nc_file(ncid)))
return NC_EBADID;
/* Find our metadata for this file, group, and var. */
assert(nc);
if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
return retval;
assert(grp && nc->nc4_info && var && var->name);
/* Where do I start reading this data? */
if (var->ndims)
{
num_values_to_start = 1;
for (d = 0; d < var->ndims; d++)
num_values_to_start *= (startp[d] * var->dim[d]->len);
}
copy_point = (void *)((char *)var->diskless_data +
num_values_to_start * var->type_info->size);
/* How many values do I copy? */
if (var->ndims)
for (d = 0; d < var->ndims; d++)
num_values *= countp[d];
/* Copy the data to memory. */
memcpy(ip, copy_point,
num_values * var->type_info->size);
return NC_NOERR;
}

49
nc_test/run_diskless.sh
View File

@ -13,47 +13,46 @@ FILE2=tst_diskless2.nc
FILE3=tst_diskless3.nc
echo ""
echo "Testing in-memory (diskless) files with and without persistence"
echo "*** Testing in-memory (diskless) files with and without persistence"
HASNC4=`../nc-config --has-nc4`
echo ""
echo "Test diskless netCDF classic file without persistence"
echo "**** Test diskless netCDF classic file without persistence"
./tst_diskless
echo "*** PASS: diskless netCDF classic file without persistence"
echo "PASS: diskless netCDF classic file without persistence"
if test "x$HASNC4" = "xyes" ; then
echo ""
echo "Test diskless netCDF enhanced file without persistence"
echo "**** Test diskless netCDF enhanced file without persistence"
./tst_diskless netcdf4
echo "*** PASS: diskless netCDF enhanced file without persistence"
echo "PASS: diskless netCDF enhanced file without persistence"
fi #HASNC4
echo ""
echo "Test diskless netCDF classic file with persistence"
echo "**** Test diskless netCDF classic file with persistence"
rm -f $FILE1
./tst_diskless persist
if test -f $FILE1 ; then
echo "$FILE1 created"
../ncdump/ncdump $FILE1
echo "***PASS: diskless netCDF classic file with persistence"
echo "**** $FILE1 created"
# ../ncdump/ncdump $FILE1
echo "PASS: diskless netCDF classic file with persistence"
else
echo "$FILE1 not created"
echo "***FAIL: diskless netCDF classic file with persistence"
echo "#### $FILE1 not created"
echo "FAIL: diskless netCDF classic file with persistence"
fi
if test "x$HASNC4" = "xyes" ; then
echo ""
echo "Test diskless netCDF enhanced file with persistence"
echo "**** Test diskless netCDF enhanced file with persistence"
rm -f $FILE1
./tst_diskless netcdf4 persist
if test -f $FILE1 ; then
echo "$FILE1 created"
../ncdump/ncdump $FILE1
echo "***PASS: diskless netCDF enhanced file with persistence"
echo "**** $FILE1 created"
# ../ncdump/ncdump $FILE1
echo "PASS: diskless netCDF enhanced file with persistence"
else
echo "$FILE1 not created"
echo "***FAIL: diskless netCDF enhanced file with persistence"
echo "FAIL: diskless netCDF enhanced file with persistence"
fi
fi #HASNC4
@ -63,11 +62,11 @@ if test "x$HASNC4" = "xyes" ; then
ok=""
echo ""
echo "Test extended enhanced diskless netCDF with persistence"
echo "**** Test extended enhanced diskless netCDF with persistence"
rm -f $FILE2 tst_diskless2.cdl
./tst_diskless2
if test -f $FILE2 ; then
echo "$FILE2 created"
echo "**** $FILE2 created"
# Do a cyle test
if ../ncdump/ncdump $FILE2 |sed -e s/tst_diskless2/tmp1/ > tmp1.cdl ; then
if ../ncgen/ncgen -k3 -o tmp1.nc tmp1.cdl ;then
@ -79,32 +78,32 @@ if test -f $FILE2 ; then
fi
fi
else
echo "$FILE2 not created"
echo "#### $FILE2 not created"
fi
rm -f tmp1.cdl tmp2.cdl tmp1.nc tmp2.nc
if test "x$ok" = xyes ; then
echo "***PASS: extended enhanced diskless netCDF with persistence"
echo "PASS: extended enhanced diskless netCDF with persistence"
else
echo "***FAIL: extended enhanced diskless netCDF with persistence"
echo "FAIL: extended enhanced diskless netCDF with persistence"
fi
fi #HASNC4
echo ""
echo "Testing nc_open in-memory (diskless) files"
echo "**** Testing nc_open in-memory (diskless) files"
# clear old files
rm -f tst_diskless3_file.cdl tst_diskless3_memory.cdl
echo ""
echo "Create and modify file without using diskless"
echo "**** Create and modify file without using diskless"
rm -f $FILE3
./tst_diskless3
../ncdump/ncdump $FILE3 >tst_diskless3_file.cdl
echo ""
echo "Create and modify file using diskless"
echo "**** Create and modify file using diskless"
rm -f $FILE3
./tst_diskless3 diskless
../ncdump/ncdump $FILE3 >tst_diskless3_memory.cdl

66
nc_test/t_nc.c
View File

@ -289,11 +289,11 @@ check_fill_seq(int id)
if(nc_get_var1_float(id, Float_id, vindices, &got.fl[0]) == -1)
goto bad_ret;
val = (float) ii;
if(val != got.fl[0])
{
parray("indices", NUM_DIMS, vindices);
(void) printf("\t%f != %f\n", val, got.fl[0]);
}
/* if(val != got.fl[0]) */
/* { */
/* parray("indices", NUM_DIMS, vindices); */
/* (void) printf("\t%f != %f\n", val, got.fl[0]); */
/* } */
(*cc)++; ii++;
continue;
}
@ -357,7 +357,7 @@ main(int ac, char *av[])
ret = nc__create(fname,NC_NOCLOBBER, initialsz, &chunksz, &id);
if(ret != NC_NOERR) {
(void) fprintf(stderr, "trying again\n");
/* (void) fprintf(stderr, "trying again\n"); */
ret = nc__create(fname,NC_CLOBBER, initialsz, &chunksz, &id);
}
if(ret != NC_NOERR)
@ -400,7 +400,7 @@ main(int ac, char *av[])
assert( nc_rename_dim(id,1, "IXX") == NC_NOERR);
assert( nc_inq_dim(id, 1, buf, &ui) == NC_NOERR);
(void) printf("dimrename: %s\n", buf);
/* (void) printf("dimrename: %s\n", buf); */
assert( nc_rename_dim(id,1, dim_names[1]) == NC_NOERR);
#ifdef ATTRX
@ -453,7 +453,7 @@ main(int ac, char *av[])
#endif /* SYNCDEBUG */
ret = nc_close(id);
(void) printf("nc_close ret = %d\n\n", ret);
/* (void) printf("nc_close ret = %d\n\n", ret); */
/*
@ -466,20 +466,20 @@ main(int ac, char *av[])
nc_strerror(ret));
exit(1);
}
(void) printf("reopen id = %d for filename %s\n",
id, fname);
/* (void) printf("reopen id = %d for filename %s\n", */
/* id, fname); */
/* NC */
(void) printf("NC ");
/* (void) printf("NC "); */
assert( nc_inq(id, &(cdesc->num_dims), &(cdesc->num_vars),
&(cdesc->num_attrs), &(cdesc->xtendim) ) == NC_NOERR);
assert((size_t) cdesc->num_dims == num_dims);
assert(cdesc->num_attrs == 1);
assert(cdesc->num_vars == NUM_TESTVARS);
(void) printf("done\n");
/* (void) printf("done\n"); */
/* GATTR */
(void) printf("GATTR ");
/* (void) printf("GATTR "); */
assert( nc_inq_attname(id, NC_GLOBAL, 0, adesc->mnem) == 0);
assert(strcmp("TITLE",adesc->mnem) == 0);
@ -491,7 +491,7 @@ main(int ac, char *av[])
assert( strcmp(fname, buf) == 0);
/* VAR */
(void) printf("VAR ");
/* (void) printf("VAR "); */
assert( cdesc->num_vars == NUM_TESTVARS );
for(ii = 0; ii < cdesc->num_vars; ii++, tvp++ )
@ -527,7 +527,7 @@ main(int ac, char *av[])
}
/* VATTR */
(void) printf("VATTR\n");
/* (void) printf("VATTR\n"); */
for(jj=0; jj<vdesc->num_attrs; jj++ )
{
assert( nc_inq_attname(id, ii, jj, adesc->mnem) == NC_NOERR);
@ -598,59 +598,59 @@ main(int ac, char *av[])
}
}
(void) printf("fill_seq ");
/* (void) printf("fill_seq "); */
check_fill_seq(id);
(void) printf("Done\n");
/* (void) printf("Done\n"); */
assert( nc_get_var1_double(id, Double_id, indices[0], &got.dbl)== NC_NOERR);
(void) printf("got val = %f\n", got.dbl );
/* (void) printf("got val = %f\n", got.dbl ); */
assert( nc_get_var1_double(id, Double_id, indices[1], &got.dbl)== NC_NOERR);
(void) printf("got val = %f\n", got.dbl );
/* (void) printf("got val = %f\n", got.dbl ); */
assert( nc_get_var1_float(id, Float_id, indices[2], &got.fl[0])== NC_NOERR);
(void) printf("got val = %f\n", got.fl[0] );
/* (void) printf("got val = %f\n", got.fl[0] ); */
assert( nc_get_var1_int(id, Long_id, indices[3], &got.in[0])== NC_NOERR);
(void) printf("got val = %d\n", got.in[0] );
/* (void) printf("got val = %d\n", got.in[0] ); */
assert( nc_get_var1_short(id, Short_id, indices[4], &got.sh[0])== NC_NOERR);
(void) printf("got val = %d\n", got.sh[0] );
/* (void) printf("got val = %d\n", got.sh[0] ); */
assert( nc_get_var1_text(id, Char_id, indices[5], &got.by[0]) == NC_NOERR);
(void) printf("got NC_CHAR val = %c (0x%02x) \n",
got.by[0] , got.by[0]);
/* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */
/* got.by[0] , got.by[0]); */
assert( nc_get_var1_text(id, Char_id, indices[6], &got.by[0]) == NC_NOERR);
(void) printf("got NC_CHAR val = %c (0x%02x) \n",
got.by[0], got.by[0] );
/* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */
/* got.by[0], got.by[0] ); */
(void) memset(buf,0,sizeof(buf));
assert( nc_get_vara_text(id, Char_id, s_start, s_edges, buf) == NC_NOERR);
(void) printf("got NC_CHAR val = \"%s\"\n", buf);
/* (void) printf("got NC_CHAR val = \"%s\"\n", buf); */
assert( nc_get_var1_schar(id, Byte_id, indices[5],
(signed char *)&got.by[0])== NC_NOERR);
(void) printf("got val = %c (0x%02x) \n", got.by[0] , got.by[0]);
/* (void) printf("got val = %c (0x%02x) \n", got.by[0] , got.by[0]); */
assert( nc_get_var1_schar(id, Byte_id, indices[6],
(signed char *)&got.by[0])== NC_NOERR);
(void) printf("got val = %c (0x%02x) \n", got.by[0], got.by[0] );
/* (void) printf("got val = %c (0x%02x) \n", got.by[0], got.by[0] ); */
(void) memset(buf,0,sizeof(buf));
assert( nc_get_vara_schar(id, Byte_id, s_start, s_edges,
(signed char *)buf)== NC_NOERR );
(void) printf("got val = \"%s\"\n", buf);
/* (void) printf("got val = \"%s\"\n", buf); */
{
double dbuf[NUM_RECS * SIZE_1 * SIZE_2];
assert(nc_get_var_double(id, Float_id, dbuf) == NC_NOERR);
(void) printf("got vals = %f ... %f\n", dbuf[0],
dbuf[NUM_RECS * SIZE_1 * SIZE_2 -1] );
/* (void) printf("got vals = %f ... %f\n", dbuf[0], */
/* dbuf[NUM_RECS * SIZE_1 * SIZE_2 -1] ); */
}
ret = nc_close(id);
(void) printf("re nc_close ret = %d\n", ret);
/* (void) printf("re nc_close ret = %d\n", ret); */
return 0;
}

2
nc_test/tst_nofill2.c
View File

@ -92,7 +92,7 @@ main(int argc, char **argv)
for (i = 0; i < NUM_TRIES; i++)
{
printf("...trying sizehint of %ld\n", sizehint);
printf(", trying sizehint of %ld ...", sizehint);
if (create_file(FILE_NAME, NC_NOFILL, &sizehint)) ERR;
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var1(ncid, 0, idx, &data)) ERR;

2
nc_test4/t_type.c
View File

@ -24,7 +24,7 @@ main(int ac, char *av[])
size_t size_in;
char name_in[NC_MAX_NAME + 1];
printf("\n *** Testing netCDF classic version of nc_inq_type...");
printf("\n*** Testing netCDF classic version of nc_inq_type...");
if (nc_inq_type(ncid, 0, name_in, &size_in) != NC_EBADTYPE) ERR;
if (nc_inq_type(ncid, NC_STRING + 1, name_in, &size_in) != NC_EBADTYPE) ERR;
if (nc_inq_type(ncid, NC_BYTE, name_in, &size_in)) ERR;

4
nc_test4/tst_chunks.c
View File

@ -72,9 +72,7 @@ main(int argc, char **argv)
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#ifdef PRINT_DEFAULT_CHUNKSIZE_TABLE
printf("**** printing table of default chunksizes...");
#endif
printf("**** testing default chunksizes...");
{
int nvars, ndims, ngatts, unlimdimid;
int contig;

2
ncdump/tst_calendars.sh
View File

@ -11,7 +11,5 @@ echo "*** creating tst_times.cdl from tst_calendars.nc with ncdump -t ..."
./ncdump -n tst_times -t tst_calendars.nc > tst_times.cdl
echo "*** comparing tst_times.cdl with ref_times.cdl..."
diff tst_times.cdl $srcdir/ref_times.cdl
echo
echo "*** All ncdump test output for -t option with CF calendar atts passed!"
exit 0

10
ncdump/tst_charfill.sh
View File

@ -1,18 +1,16 @@
#!/bin/sh
# This shell script runs an ncgen buf in handling character _Fillvalue.
set -x
set -e
echo ""
echo "*** Running char _Fillvalue bug test."
echo "*** Testing char _Fillvalue bug fix."
echo "*** Create tst_charfill.nc from tst_charfill.cdl..."
# echo "*** Create tst_charfill.nc from tst_charfill.cdl..."
rm -f tst_charfill.nc tmp_tst_charfill.cdl
../ncgen/ncgen -b -o tst_charfill.nc $srcdir/tst_charfill.cdl
echo "*** dumping tst_charfill.nc to tmp_tst_charfill.cdl..."
# echo "*** dumping tst_charfill.nc to tmp_tst_charfill.cdl..."
./ncdump tst_charfill.nc > tmp_tst_charfill.cdl
echo "*** comparing tmp_tst_charfill.cdl with ref_tst_charfill.cdl..."
# echo "*** comparing tmp_tst_charfill.cdl with ref_tst_charfill.cdl..."
diff tmp_tst_charfill.cdl $srcdir/ref_tst_charfill.cdl
echo
echo "*** All char _Fillvalue bug test for netCDF-4 format passed!"
exit 0

2
ncdump/tst_chunking.c
View File

@ -28,7 +28,7 @@ main(int argc, char **argv) {
float fvar_data[NVALS];
int r, i;
printf("*** creating chunkable test file %s...\n", FILE_NAME);
printf("*** Creating chunkable test file %s...", FILE_NAME);
if (nc_create(FILE_NAME, NC_CLOBBER, &ncid)) ERR;
for(r = 0; r < VAR_RANK; r++) {

5
ncdump/tst_fillbug.sh
View File

@ -6,11 +6,10 @@ set -e
echo ""
echo "*** Running ncdump bug test."
echo "*** dumping tst_fillbug.nc to tst_fillbug.cdl..."
# echo "*** dumping tst_fillbug.nc to tst_fillbug.cdl..."
./ncdump tst_fillbug.nc > tst_fillbug.cdl
echo "*** comparing tst_fillbug.cdl with ref_tst_fillbug.cdl..."
# echo "*** comparing tst_fillbug.cdl with ref_tst_fillbug.cdl..."
diff tst_fillbug.cdl $srcdir/ref_tst_fillbug.cdl
echo
echo "*** All ncdump bug test output for netCDF-4 format passed!"
exit 0

1
ncdump/tst_grp_spec.sh
View File

@ -13,6 +13,5 @@ echo "*** creating tmp_subset.cdl from tmp_all.nc with ncdump -g ..."
echo "*** comparing tmp_subset.cdl with ref_tst_grp_spec.cdl..."
diff tmp_subset.cdl $srcdir/ref_tst_grp_spec.cdl
echo
echo "*** All ncdump test output for -g option passed!"
exit 0

7
ncdump/tst_iter.sh
View File

@ -3,7 +3,7 @@
# Test if the nciter code is working [NCF-154]
set -e
echo ""
echo "*** Running ncdump nc_iter test."
if test "x$CC" = "x" ; then CC="gcc"; fi
@ -12,7 +12,7 @@ CLEANUP="iter.*"
rm -f $CLEANUP
echo "create iter.cdl"
# echo "create iter.cdl"
cat > iter.cdl <<EOF
netcdf iter {
dimensions:
@ -39,7 +39,7 @@ EOF
$CC ./iter.c -o iter.exe
./iter.exe >>iter.cdl
echo "*** create iter.nc "
# echo "*** create iter.nc "
../ncgen/ncgen -k1 -o iter.nc ./iter.cdl
echo "*** dumping iter.nc to iter.dmp"
./ncdump iter.nc > iter.dmp
@ -53,5 +53,4 @@ diff -w ./iter.dmp ./iter.cdl
# cleanup
rm -f $CLEANUP
echo "*** PASS: ncdump iter tests"
exit 0

8
ncdump/tst_nccopy3.sh
View File

@ -9,25 +9,21 @@ TESTFILES='c0 c0tmp ctest0 ctest0_64 small small2 test0 test1
echo "*** Testing netCDF-3 features of nccopy on ncdump/*.nc files"
for i in $TESTFILES ; do
echo "*** copy $i.nc to copy_of_$i.nc ..."
echo "*** Testing nccopy $i.nc copy_of_$i.nc ..."
./nccopy $i.nc copy_of_$i.nc
./ncdump -n copy_of_$i $i.nc > tmp.cdl
./ncdump copy_of_$i.nc > copy_of_$i.cdl
echo "*** compare " with copy_of_$i.cdl
diff copy_of_$i.cdl tmp.cdl
rm copy_of_$i.nc copy_of_$i.cdl tmp.cdl
done
echo "*** Test nccopy -u"
echo "*** creating tst_brecs.nc from tst_brecs.cdl..."
echo "*** Testing nccopy -u"
../ncgen/ncgen -b $srcdir/tst_brecs.cdl
# convert record dimension to fixed-size dimension
./nccopy -u tst_brecs.nc copy_of_tst_brecs.nc
./ncdump -n copy_of_tst_brecs tst_brecs.nc | sed '/ = UNLIMITED ;/s/\(.*\) = UNLIMITED ; \/\/ (\(.*\) currently)/\1 = \2 ;/' > tmp.cdl
./ncdump copy_of_tst_brecs.nc > copy_of_tst_brecs.cdl
echo "*** compare result of nccopy -u with expected result ..."
diff copy_of_tst_brecs.cdl tmp.cdl
rm copy_of_tst_brecs.cdl tmp.cdl tst_brecs.nc copy_of_tst_brecs.nc
echo
echo "*** All nccopy tests passed!"
exit 0

12
ncdump/tst_nccopy4.sh
View File

@ -14,15 +14,15 @@ TESTFILES='tst_comp tst_comp2 tst_enum_data tst_fillbug
echo "*** Testing netCDF-4 features of nccopy on ncdump/*.nc files"
for i in $TESTFILES ; do
echo "*** copy $i.nc to copy_of_$i.nc ..."
echo "*** Test nccopy $i.nc copy_of_$i.nc ..."
./nccopy $i.nc copy_of_$i.nc
./ncdump -n copy_of_$i $i.nc > tmp.cdl
./ncdump copy_of_$i.nc > copy_of_$i.cdl
echo "*** compare " with copy_of_$i.cdl
# echo "*** compare " with copy_of_$i.cdl
diff copy_of_$i.cdl tmp.cdl
rm copy_of_$i.nc copy_of_$i.cdl tmp.cdl
done
echo "*** Create deflatable files for testing ..."
# echo "*** Testing compression of deflatable files ..."
./tst_compress
echo "*** Test nccopy -d1 can compress a classic format file ..."
./nccopy -d1 tst_inflated.nc tst_deflated.nc
@ -48,15 +48,14 @@ rm tst_deflated.nc tst_inflated.nc tst_inflated4.nc tmp.nc
echo "*** Testing nccopy -d1 -s on ncdump/*.nc files"
for i in $TESTFILES ; do
echo "*** nccopy -d1 -s $i.nc copy_of_$i.nc ..."
echo "*** Test nccopy -d1 -s $i.nc copy_of_$i.nc ..."
./nccopy -d1 -s $i.nc copy_of_$i.nc
./ncdump -n copy_of_$i $i.nc > tmp.cdl
./ncdump copy_of_$i.nc > copy_of_$i.cdl
echo "*** compare " with copy_of_$i.cdl
# echo "*** compare " with copy_of_$i.cdl
diff copy_of_$i.cdl tmp.cdl
rm copy_of_$i.nc copy_of_$i.cdl tmp.cdl
done
echo "*** Create chunkable file for testing ..."
./tst_chunking
echo "*** Test that nccopy -c can chunk and unchunk files"
./nccopy tst_chunking.nc tmp.nc
@ -70,6 +69,5 @@ diff tmp.cdl tmp-unchunked.cdl
# echo "*** Test that nccopy compression with chunking can improve compression"
rm tst_chunking.nc tmp.nc tmp.cdl tmp-chunked.nc tmp-chunked.cdl tmp-unchunked.nc tmp-unchunked.cdl
echo
echo "*** All nccopy tests passed!"
exit 0

12
ncdump/tst_ncgen4.sh
View File

@ -19,19 +19,19 @@ export srcdir
export builddir
KFLAG=1 ; export KFLAG
echo "Performing diff tests: k=1"
echo "*** Performing diff tests: k=1"
sh ${srcdir}/tst_ncgen4_diff.sh
echo "Performing cycle tests: k=1"
echo "*** Performing cycle tests: k=1"
sh ${srcdir}/tst_ncgen4_cycle.sh
KFLAG=3 ; export KFLAG
echo "Performing diff tests: k=3"
echo "*** Performing diff tests: k=3"
sh ${srcdir}/tst_ncgen4_diff.sh
echo "Performing cycle tests: k=3"
echo "*** Performing cycle tests: k=3"
sh ${srcdir}/tst_ncgen4_cycle.sh
KFLAG=4 ; export KFLAG
echo "Performing diff tests: k=4"
echo "*** Performing diff tests: k=4"
sh ${srcdir}/tst_ncgen4_diff.sh
echo "Performing cycle tests: k=4"
echo "*** Performing cycle tests: k=4"
sh ${srcdir}/tst_ncgen4_cycle.sh
exit

2
ncdump/tst_ncgen4_classic.sh
View File

@ -1,7 +1,7 @@
#!/bin/sh
set -e
echo ""
verbose=0
if test "x$builddir" = "x"; then builddir=`pwd`; fi

50
ncdump/tst_netcdf4.sh
View File

@ -5,63 +5,54 @@
set -e
echo ""
echo "*** Testing ncgen and ncdump test output for netCDF-4 format."
echo "*** creating netcdf-4 file c0.nc from c0.cdl..."
# echo "*** creating netcdf-4 file c0.nc from c0.cdl..."
../ncgen/ncgen -k3 -b -o c0.nc $srcdir/../ncgen/c0.cdl
echo "*** creating c1.cdl from c0.nc..."
# echo "*** creating c1.cdl from c0.nc..."
./ncdump -n c1 c0.nc > c1.cdl
echo "*** comparing c1.cdl with ref_ctest1_nc4.cdl..."
# echo "*** comparing c1.cdl with ref_ctest1_nc4.cdl..."
diff c1.cdl $srcdir/ref_ctest1_nc4.cdl
echo
echo "*** Testing ncgen and ncdump test output for netCDF-4 classic format."
echo "*** creating netcdf-4 classic file c0.nc from c0.cdl..."
# echo "*** creating netcdf-4 classic file c0.nc from c0.cdl..."
../ncgen/ncgen -k4 -b -o c0.nc $srcdir/../ncgen/c0.cdl
echo "*** creating c1.cdl from c0.nc..."
# echo "*** creating c1.cdl from c0.nc..."
./ncdump -n c1 c0.nc > c1.cdl
echo "*** comparing c1.cdl with ref_ctest1_nc4c.cdl..."
# echo "*** comparing c1.cdl with ref_ctest1_nc4c.cdl..."
diff c1.cdl $srcdir/ref_ctest1_nc4c.cdl
echo
echo "*** Testing ncdump output for netCDF-4 features."
echo "*** dumping tst_solar_1.nc to tst_solar_1.cdl..."
./ncdump tst_solar_1.nc > tst_solar_1.cdl
echo "*** comparing tst_solar_1.cdl with ref_tst_solar_1.cdl..."
# echo "*** comparing tst_solar_1.cdl with ref_tst_solar_1.cdl..."
diff tst_solar_1.cdl $srcdir/ref_tst_solar_1.cdl
echo "*** dumping tst_solar_2.nc to tst_solar_2.cdl..."
./ncdump tst_solar_2.nc > tst_solar_2.cdl
echo "*** comparing tst_solar_2.cdl with ref_tst_solar_2.cdl..."
# echo "*** comparing tst_solar_2.cdl with ref_tst_solar_2.cdl..."
diff tst_solar_2.cdl $srcdir/ref_tst_solar_2.cdl
echo "*** dumping tst_group_data.nc to tst_group_data.cdl..."
./ncdump tst_group_data.nc > tst_group_data.cdl
echo "*** comparing tst_group_data.cdl with ref_tst_group_data.cdl..."
# echo "*** comparing tst_group_data.cdl with ref_tst_group_data.cdl..."
diff tst_group_data.cdl $srcdir/ref_tst_group_data.cdl
echo "*** testing -v option with absolute name and groups..."
echo "*** Testing -v option with absolute name and groups..."
./ncdump -v /g2/g3/var tst_group_data.nc > tst_group_data.cdl
echo "*** comparing tst_group_data.cdl with ref_tst_group_data_v23.cdl..."
# echo "*** comparing tst_group_data.cdl with ref_tst_group_data_v23.cdl..."
diff tst_group_data.cdl $srcdir/ref_tst_group_data_v23.cdl
echo "*** testing -v option with relative name and groups..."
echo "*** Testing -v option with relative name and groups..."
./ncdump -v var,var2 tst_group_data.nc > tst_group_data.cdl
echo "*** comparing tst_group_data.cdl with ref_tst_group_data.cdl..."
# echo "*** comparing tst_group_data.cdl with ref_tst_group_data.cdl..."
diff tst_group_data.cdl $srcdir/ref_tst_group_data.cdl
echo "*** dumping tst_enum_data.nc to tst_enum_data.cdl..."
./ncdump tst_enum_data.nc > tst_enum_data.cdl
echo "*** comparing tst_enum_data.cdl with ref_tst_enum_data.cdl..."
# echo "*** comparing tst_enum_data.cdl with ref_tst_enum_data.cdl..."
diff tst_enum_data.cdl $srcdir/ref_tst_enum_data.cdl
echo "*** dumping tst_opaque_data.nc to tst_opaque_data.cdl..."
./ncdump tst_opaque_data.nc > tst_opaque_data.cdl
echo "*** comparing tst_opaque_data.cdl with ref_tst_opaque_data.cdl..."
# echo "*** comparing tst_opaque_data.cdl with ref_tst_opaque_data.cdl..."
diff tst_opaque_data.cdl $srcdir/ref_tst_opaque_data.cdl
echo "*** dumping tst_vlen_data.nc to tst_vlen_data.cdl..."
./ncdump tst_vlen_data.nc > tst_vlen_data.cdl
echo "*** comparing tst_vlen_data.cdl with ref_tst_vlen_data.cdl..."
# echo "*** comparing tst_vlen_data.cdl with ref_tst_vlen_data.cdl..."
diff tst_vlen_data.cdl $srcdir/ref_tst_vlen_data.cdl
echo "*** dumping tst_comp.nc to tst_comp.cdl..."
./ncdump tst_comp.nc > tst_comp.cdl
echo "*** comparing tst_comp.cdl with ref_tst_comp.cdl..."
# echo "*** comparing tst_comp.cdl with ref_tst_comp.cdl..."
diff tst_comp.cdl $srcdir/ref_tst_comp.cdl
echo "*** creating tst_nans.cdl from tst_nans.nc"
# echo "*** creating tst_nans.cdl from tst_nans.nc"
./ncdump tst_nans.nc > tst_nans.cdl
echo "*** comparing ncdump of generated file with ref_tst_nans.cdl ..."
# echo "*** comparing ncdump of generated file with ref_tst_nans.cdl ..."
diff tst_nans.cdl $srcdir/ref_tst_nans.cdl
# Do unicode test only if it exists => BUILD_UTF8 is true
if test -f ./tst_unicode -o -f ./tst_unicode.exe ; then
@ -70,14 +61,11 @@ if test -f ./tst_unicode -o -f ./tst_unicode.exe ; then
./ncdump tst_unicode.nc > tst_unicode.cdl
#echo "*** comparing tst_unicode.cdl with ref_tst_unicode.cdl..."
#diff tst_unicode.cdl $srcdir/ref_tst_unicode.cdl
echo "*** generating tst_nans.nc"
fi
./tst_special_atts
echo "*** dumping tst_special_atts.nc to tst_special_atts.cdl..."
./ncdump -c -s tst_special_atts.nc > tst_special_atts.cdl
echo "*** comparing tst_special_atts.cdl with ref_tst_special_atts.cdl..."
diff tst_special_atts.cdl $srcdir/ref_tst_special_atts.cdl
echo
echo "*** All ncgen and ncdump test output for netCDF-4 format passed!"
exit 0

1
ncdump/tst_netcdf4_4.sh
View File

@ -26,6 +26,5 @@ echo '*** testing reference file ref_tst_compounds4.nc...'
./ncdump $srcdir/ref_tst_compounds4.nc > tst_compounds4.cdl
diff tst_compounds4.cdl $srcdir/ref_tst_compounds4.cdl
echo
echo "*** All ncgen and ncdump extra test output for netCDF-4 format passed!"
exit 0

8
win32/Makefile.am
View File

@ -1,8 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
SUBDIRS = NET

11
win32/NET/Makefile.am
View File

@ -1,11 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.4 2008/09/29 15:17:54 ed Exp $
SUBDIRS = examples libsrc ncdump ncgen nctest nc_test
EXTRA_DIST = config.h getopt.c netcdf.sln inttypes.h stdint.h

560
win32/NET/config.h
View File

@ -1,560 +0,0 @@
/* config.h. Generated from config.h.in by configure. */
/* config.h.in. Generated from configure.ac by autoheader. */
/* What sort of HTTP client is this? */
/* #undef CNAME */
/* Should the subprocess compression for Server3 be includes? */
/* #undef COMPRESSION_FOR_SERVER3 */
#define DEFAULT_CHUNK_SIZE 4194304
/* num chunks in default per-var chunk cache. */
#define DEFAULT_CHUNKS_IN_CACHE 10
/* max size of the default per-var chunk cache. */
#define MAX_DEFAULT_CACHE_SIZE 67108864
/* default chunk cache nelems. */
#define CHUNK_CACHE_NELEMS 1000
//#define CHUNK_CACHE_NELEMS 1009
/* default chunk cache preemption policy. */
#define CHUNK_CACHE_PREEMPTION 0.75
/* default chunk cache size in bytes. */
#define CHUNK_CACHE_SIZE 32000000
//#define CHUNK_CACHE_SIZE 4194304
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
systems. This function is required for `alloca.c' support on those systems.
*/
/* #undef CRAY_STACKSEG_END */
/* Client version number */
/* #undef CVER */
/* Define to 1 if using `alloca.c'. */
/* #undef C_ALLOCA */
/* What DAP version is supported? */
/* #undef DAP_PROTOCOL_VERSION */
/* dbyte */
/* #undef DBYTE */
/* dfloat32 */
/* #undef DFLOAT32 */
/* dfloat64 */
/* #undef DFLOAT64 */
/* dint16 */
/* #undef DINT16 */
/* int32 */
/* #undef DINT32 */
/* set this only when building a DLL under MinGW */
/* #undef DLL_NETCDF */
#define DLL_NETCDF 1
/* uint16 */
/* #undef DUINT16 */
/* uint32 */
/* #undef DUINT32 */
/* Client name and version combined */
/* #undef DVR */
/* Should all the classes run ConstraintEvaluator::eval()? */
/* #undef EVAL */
/* if true, run extra tests which may not work with HDF5 beta release */
/* #undef EXTRA_TESTS */
/* use HDF5 1.6 API */
#define H5_USE_16_API 1
/* Define to 1 if you have the `alarm' function. */
/* #undef HAVE_ALARM */
/* Define to 1 if you have `alloca', as a function or macro. */
/*#define HAVE_ALLOCA 1*/
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
/*#define HAVE_ALLOCA_H 1*/
/* Define to 1 if you have the `atexit' function. */
/* #undef HAVE_ATEXIT */
/* Define to 1 if you have the `bzero' function. */
/* #undef HAVE_BZERO */
/* Define to 1 if you have the declaration of `isfinite', and to 0 if you
don't. */
/*#define HAVE_DECL_ISFINITE 1*/
/* Define to 1 if you have the declaration of `isinf', and to 0 if you don't.
*/
/*#define HAVE_DECL_ISINF 1*/
/* Define to 1 if you have the declaration of `isnan', and to 0 if you don't.
*/
/*#define HAVE_DECL_ISNAN 1*/
/* Define to 1 if you have the declaration of `signbit', and to 0 if you
don't. */
#define HAVE_DECL_SIGNBIT 1
/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_DIRENT_H */
/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1
/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
/* #undef HAVE_DOPRNT */
/* Define to 1 if you have the `dup2' function. */
/* #undef HAVE_DUP2 */
/* Define to 1 if you have the <fcntl.h> header file. */
/* #undef HAVE_FCNTL_H */
/* Define to 1 if you have the <float.h> header file. */
/* #undef HAVE_FLOAT_H */
/* Define to 1 if you have the `floor' function. */
/* #undef HAVE_FLOOR */
/* Define to 1 if you have the `getcwd' function. */
/* #undef HAVE_GETCWD */
/* Define to 1 if you have the `getpagesize' function. */
/* #undef HAVE_GETPAGESIZE */
/* Define to 1 if you have the <hdf5.h> header file. */
#define HAVE_HDF5_H 1
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the `hdf5' library (-lhdf5). */
#define HAVE_LIBHDF5 1
/* Define to 1 if you have the `hdf5_hl' library (-lhdf5_hl). */
#define HAVE_LIBHDF5_HL 1
/* Define to 1 if you have the <limits.h> header file. */
/* #undef HAVE_LIMITS_H */
/* Define to 1 if you have the `localtime_r' function. */
/* #undef HAVE_LOCALTIME_R */
/* Define to 1 if the system has the type `long long int'. */
#define HAVE_LONG_LONG_INT 1
/* Define to 1 if you have the <malloc.h> header file. */
/* #undef HAVE_MALLOC_H */
/* Define to 1 if you have the `memchr' function. */
/* #undef HAVE_MEMCHR */
/* Define to 1 if you have the `memmove' function. */
/* #undef HAVE_MEMMOVE */
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `memset' function. */
/* #undef HAVE_MEMSET */
/* Define to 1 if you have the `mktime' function. */
/* #undef HAVE_MKTIME */
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
/* #undef HAVE_NDIR_H */
/* Define to 1 if you have the <netinet/in.h> header file. */
/* #undef HAVE_NETINET_IN_H */
/* Define to 1 if you have the `pow' function. */
/* #undef HAVE_POW */
/* Define to 1 if the system has the type `ptrdiff_t'. */
#define HAVE_PTRDIFF_T 1
/* Define to 1 if you have the `putenv' function. */
/* #undef HAVE_PUTENV */
/* Define to 1 if you have the `regcomp' function. */
/* #undef HAVE_REGCOMP */
/* Define to 1 if you have the `setenv' function. */
/* #undef HAVE_SETENV */
/* Define to 1 if the system has the type `ssize_t'. */
/*#define HAVE_SSIZE_T 1*/
/* Define to 1 if you have the <sstream> header file. */
/* #undef HAVE_SSTREAM */
/* Define to 1 if stdbool.h conforms to C99. */
/*#define HAVE_STDBOOL_H 1*/
/* Define to 1 if you have the <stddef.h> header file. */
/* #undef HAVE_STDDEF_H */
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the `strchr' function. */
/* #undef HAVE_STRCHR */
/* Define to 1 if you have the `strerror' function. */
#define HAVE_STRERROR 1
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strlcat' function. */
/*#define HAVE_STRLCAT 1*/
/* Define to 1 if you have the `strrchr' function. */
/* #undef HAVE_STRRCHR */
/* Define to 1 if you have the `strstr' function. */
/* #undef HAVE_STRSTR */
/* Define to 1 if you have the `strtol' function. */
/* #undef HAVE_STRTOL */
/* Define to 1 if you have the `strtoul' function. */
/* #undef HAVE_STRTOUL */
/* Define to 1 if `st_blksize' is member of `struct stat'. */
/*#define HAVE_STRUCT_STAT_ST_BLKSIZE 1*/
/* Define to 1 if your `struct stat' has `st_blksize'. Deprecated, use
`HAVE_STRUCT_STAT_ST_BLKSIZE' instead. */
/*#define HAVE_ST_BLKSIZE 1*/
/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_DIR_H */
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_NDIR_H */
/* Define to 1 if you have the <sys/param.h> header file. */
/* #undef HAVE_SYS_PARAM_H */
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/time.h> header file. */
/* #undef HAVE_SYS_TIME_H */
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
/* #undef HAVE_SYS_WAIT_H */
/* Define to 1 if you have the `timegm' function. */
/* #undef HAVE_TIMEGM */
/* Define to 1 if the system has the type `uchar'. */
/* #undef HAVE_UCHAR */
/* Define to 1 if you have the <unistd.h> header file. */
/*#define HAVE_UNISTD_H 1*/
/* Added to fool ncgen. */
#define YY_NO_UNISTD_H 1
/* Define to 1 if the system has the type `unsigned long long int'. */
#define HAVE_UNSIGNED_LONG_LONG_INT 1
/* Define to 1 if you have the `vprintf' function. */
/* #undef HAVE_VPRINTF */
/* Define to 1 if the system has the type `_Bool'. */
/*#define HAVE__BOOL 1*/
/* if true, use HDF5 data conversions */
/* #undef HDF5_CONVERT */
/* do large file tests */
/* #undef LARGE_FILE_TESTS */
/* Set to the prefix directory */
/* #undef LIBDAP_ROOT */
/* if true, turn on netCDF-4 logging */
/* #undef LOGGING */
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#define LT_OBJDIR ".libs/"
/* type definition */
#define NCBYTE_T byte
/* type definition */
#define NCSHORT_T integer*2
/* default */
#define NF_DOUBLEPRECISION_IS_C_DOUBLE 1
/* default */
#define NF_INT1_IS_C_SIGNED_CHAR 1
/* type thing */
#define NF_INT1_T byte
/* default */
#define NF_INT2_IS_C_SHORT 1
/* type thing */
#define NF_INT2_T integer*2
/* default */
#define NF_INT_IS_C_INT 1
//#define NF_INT_IS_C_LONG 1
/* default */
#define NF_REAL_IS_C_FLOAT 1
/* no IEEE float on this platform */
/* #undef NO_IEEE_FLOAT */
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */
/* do not build the netCDF version 2 API */
/* #undef NO_NETCDF_2 */
//#define NO_NETCDF_2 1
/* no stdlib.h */
/* #undef NO_STDLIB_H */
/* no sys_types.h */
/* #undef NO_SYS_TYPES_H */
/* Name of package */
#define PACKAGE "netcdf"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "support@unidata.ucar.edu"
/* Define to the full name of this package. */
#define PACKAGE_NAME "netCDF"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "netCDF 4.1.3"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "netcdf"
/* Define to the version of this package. */
#define PACKAGE_VERSION "4.1.3"
/* Define as the return type of signal handlers (`int' or `void'). */
/* #undef RETSIGTYPE */
/* The size of `char', as computed by sizeof. */
/* #undef SIZEOF_CHAR */
/* The size of `double', as computed by sizeof. */
#define SIZEOF_DOUBLE 8
/* The size of `float', as computed by sizeof. */
#define SIZEOF_FLOAT 4
/* The size of `int', as computed by sizeof. */
#define SIZEOF_INT 4
/* The size of `int16_t', as computed by sizeof. */
/* #undef SIZEOF_INT16_T */
/* The size of `int32_t', as computed by sizeof. */
/* #undef SIZEOF_INT32_T */
/* The size of `long', as computed by sizeof. */
#define SIZEOF_LONG 4
/* The size of `off_t', as computed by sizeof. */
#define SIZEOF_OFF_T 8
/* The size of `short', as computed by sizeof. */
#define SIZEOF_SHORT 2
/* The size of `size_t', as computed by sizeof. */
#ifdef _WIN64
typedef unsigned __int64 size_t;
typedef __int64 ssize_t;
#define SIZEOF_SIZE_T 8
#else
typedef unsigned int size_t;
typedef int ssize_t;
#define SIZEOF_SIZE_T 4
#endif
/* The size of `uint16_t', as computed by sizeof. */
/* #undef SIZEOF_UINT16_T */
/* The size of `uint32_t', as computed by sizeof. */
/* #undef SIZEOF_UINT32_T */
/* The size of `uint8_t', as computed by sizeof. */
/* #undef SIZEOF_UINT8_T */
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Place to put very large netCDF test files. */
#define TEMP_LARGE "."
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
/* #undef TIME_WITH_SYS_TIME */
/* if true, build DAP Client */
#define USE_DAP 1
/* if true, build DAP Client */
#define ENABLE_DAP 1
/* if true, do remote tests */
#define ENABLE_DAP_REMOTE_TESTS 1
/* set this to use extreme numbers in tests */
#define USE_EXTREME_NUMBERS 1
/* if true, build netCDF-4 */
#define USE_NETCDF4 1
/*#define HAVE_GETOPT_H 1*/
/* if true, parallel netCDF-4 is in use */
/* #undef USE_PARALLEL */
/* if true, compile in parallel netCDF-4 based on MPI/IO */
/* #undef USE_PARALLEL_MPIO */
/* if true, compile in parallel netCDF-4 based on MPI/POSIX */
/* #undef USE_PARALLEL_POSIX */
/* if true, build libsrc code with renamed API functions */
#define USE_RENAMEV3 1
/* if true, compile in zlib compression in netCDF-4 variables */
#define USE_ZLIB 1
/* Version number of package */
//#define VERSION "4.1.3"
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel and VAX). */
#if defined __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
#elif ! defined __LITTLE_ENDIAN__
/* # undef WORDS_BIGENDIAN */
#endif
/* xdr float32 */
/* #undef XDR_FLOAT32 */
/* xdr float64 */
/* #undef XDR_FLOAT64 */
/* xdr int16 */
/* #undef XDR_INT16 */
/* xdr int32 */
/* #undef XDR_INT32 */
/* xdr uint16 */
/* #undef XDR_UINT16 */
/* xdr uint32 */
/* #undef XDR_UINT32 */
/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */
/* Needed by HPUX with c89 compiler. */
/* #undef _HPUX_SOURCE */
/* Define for large files, on AIX-style hosts. */
/* #undef _LARGE_FILES */
/* Define to 1 if type `char' is unsigned and you are not using gcc. */
#ifndef __CHAR_UNSIGNED__
/* # undef __CHAR_UNSIGNED__ */
#endif
/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */
/* Turned on by netCDF configure. */
/* #undef f2cFortran */
/* Turned on by netCDF configure. */
/* #undef gFortran */
/* Define to `long int' if <sys/types.h> does not define. */
/* #undef off_t */
/* Turned on by netCDF configure. */
#define pgiFortran 1
/* #define INTEL_COMPILER 1 */
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
/* Define to empty if the keyword `volatile' does not work. Warning: valid
code using `volatile' can become incorrect without. Disable with care. */
/* #undef volatile */
/* Shorthand for gcc's unused attribute feature */
#if defined(__GNUG__) || defined(__GNUC__)
#define not_used __attribute__ ((unused))
#else
#define not_used
#endif /* __GNUG__ || __GNUC__ */
/* I added the following to this config.h file by hand, after being abducted by
aliens last week in Kansas. (All Hail Zorlock, Mighty Destroyer of Worlds!) */
#include <io.h>
#include <process.h>
#define lseek _lseeki64
#define off_t __int64
#define _off_t __int64
#define _OFF_T_DEFINED
#define snprintf sprintf_s
#define strcasecmp _stricmp
#define strtoll _strtoi64
#define HAVE_STRDUP 1
#define HAVE_RPC_XDR_H 1
#define HAVE_RPC_TYPES_H 1

58
win32/NET/examples/AssemblyInfo.cpp
View File

@ -1,58 +0,0 @@
#include "stdafx.h"
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("")];
[assembly:AssemblyCopyrightAttribute("")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("1.0.*")];
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project directory.
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly:AssemblyDelaySignAttribute(false)];
[assembly:AssemblyKeyFileAttribute("")];
[assembly:AssemblyKeyNameAttribute("")];

15
win32/NET/examples/Form1.cpp
View File

@ -1,15 +0,0 @@
#include "stdafx.h"
#include "Form1.h"
#include <windows.h>
using namespace tst_netcdf;
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
System::Threading::Thread::CurrentThread->ApartmentState = System::Threading::ApartmentState::STA;
Application::Run(new Form1());
return 0;
}

150
win32/NET/examples/Form1.h
View File

@ -1,150 +0,0 @@
#pragma once
#include <netcdf.h>
namespace tst_netcdf
{
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
/// <summary>
/// Summary for Form1
///
/// WARNING: If you change the name of this class, you will need to change the
/// 'Resource File Name' property for the managed resource compiler tool
/// associated with all .resx files this class depends on. Otherwise,
/// the designers will not be able to interact properly with localized
/// resources associated with this form.
/// </summary>
public __gc class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
}
protected:
void Dispose(Boolean disposing)
{
if (disposing && components)
{
components->Dispose();
}
__super::Dispose(disposing);
}
private: System::Windows::Forms::Button * button1;
private: System::Windows::Forms::TextBox * textBox1;
private:
/// <summary>
/// Required designer variable.
/// </summary>
System::ComponentModel::Container * components;
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
void InitializeComponent(void)
{
this->button1 = new System::Windows::Forms::Button();
this->textBox1 = new System::Windows::Forms::TextBox();
this->SuspendLayout();
//
// button1
//
this->button1->Location = System::Drawing::Point(88, 40);
this->button1->Name = S"button1";
this->button1->TabIndex = 0;
this->button1->Text = S"Push Me!";
this->button1->Click += new System::EventHandler(this, &tst_netcdf::Form1::button1_Click);
//
// textBox1
//
this->textBox1->Location = System::Drawing::Point(40, 104);
this->textBox1->Multiline = true;
this->textBox1->Name = S"textBox1";
this->textBox1->Size = System::Drawing::Size(224, 152);
this->textBox1->TabIndex = 1;
this->textBox1->Text = S"";
//
// Form1
//
this->AutoScaleBaseSize = System::Drawing::Size(5, 13);
this->ClientSize = System::Drawing::Size(292, 273);
this->Controls->Add(this->textBox1);
this->Controls->Add(this->button1);
this->Name = S"Form1";
this->Text = S"Form1";
this->ResumeLayout(false);
}
private: System::Void button1_Click(System::Object * sender, System::EventArgs * e)
{
int ncid, varid;
int dimids[2];
int temp_data[10][5];
int res;
// phoney up some data.
for (int i=0; i<10; i++)
for (int j=0; j<5; j++)
temp_data[i][j] = 100 + i;
textBox1->AppendText("Creating file...");
if ((res = nc__create("test.nc", NC_CLOBBER, 0, NULL, &ncid)))
{
textBox1->AppendText("error creating: ");
textBox1->AppendText(nc_strerror(res));
return;
}
textBox1->AppendText("Defining dims...");
if ((res = nc_def_dim(ncid, "lat", 10, &(dimids[0]))))
{
textBox1->AppendText("error nc_def_dim: ");
textBox1->AppendText(nc_strerror(res));
return;
}
if ((res = nc_def_dim(ncid, "lon", 5, &dimids[1])))
{
textBox1->AppendText("error nc_def_dim: ");
textBox1->AppendText(nc_strerror(res));
return;
}
if ((res = nc_def_var(ncid, "temp", NC_INT, 2, dimids, &varid)))
{
textBox1->AppendText("error nc_def_dim: ");
textBox1->AppendText(nc_strerror(res));
return;
}
textBox1->AppendText("Ending definition...");
if ((res = nc_enddef(ncid)))
{
textBox1->AppendText("error nc_enddef: ");
textBox1->AppendText(nc_strerror(res));
return;
}
textBox1->AppendText("Writing data...");
if ((res = nc_put_var_int(ncid, varid, &temp_data[0][0])))
{
textBox1->AppendText("error nc_put_var_int: ");
textBox1->AppendText(nc_strerror(res));
return;
}
if ((res = nc_close(ncid)))
{
textBox1->AppendText("\nerror nc_close: ");
textBox1->AppendText(nc_strerror(res));
return;
}
}
};
}

136
win32/NET/examples/Form1.resX
View File

@ -1,136 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 1.3
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">1.3</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1">this is my long string</data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
[base64 mime encoded serialized .NET Framework object]
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
[base64 mime encoded string representing a byte array form of the .NET Framework object]
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used forserialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>1.3</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="button1.Locked" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</data>
<data name="button1.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>Private</value>
</data>
<data name="textBox1.Locked" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</data>
<data name="textBox1.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>Private</value>
</data>
<data name="$this.TrayLargeIcon" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</data>
<data name="$this.TrayHeight" type="System.Int32, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>80</value>
</data>
<data name="$this.Localizable" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</data>
<data name="$this.SnapToGrid" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>True</value>
</data>
<data name="$this.DrawGrid" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>True</value>
</data>
<data name="$this.Locked" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</data>
<data name="$this.GridSize" type="System.Drawing.Size, System.Drawing, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>8, 8</value>
</data>
<data name="$this.Language" type="System.Globalization.CultureInfo, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>(Default)</value>
</data>
</root>

9
win32/NET/examples/Makefile.am
View File

@ -1,9 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# Include the .NET stuff.
# $Id: Makefile.am,v 1.2 2008/09/29 15:39:26 ed Exp $
EXTRA_DIST = app.ico AssemblyInfo.cpp Form1.cpp Form1.resX stdafx.cpp \
tst_netcdf.vcproj app.rc Form1.h stdafx.h resource.h

BIN
win32/NET/examples/app.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

52
win32/NET/examples/app.rc
View File

@ -1,52 +0,0 @@
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// English (U.S.) resources
/////////////////////////////////////////////////////////////////////////////
//
// Icon
//
// Icon placed first or with lowest ID value becomes application icon
LANGUAGE 9, 1
#pragma code_page(1252)
1 ICON "app.ico"
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

1
win32/NET/examples/resource.h
View File

@ -1 +0,0 @@
/* Deliberately empty file to fool visual studio. */

7
win32/NET/examples/stdafx.cpp
View File

@ -1,7 +0,0 @@
// stdafx.cpp : source file that includes just the standard includes
// tst_netcdf.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"

14
win32/NET/examples/stdafx.h
View File

@ -1,14 +0,0 @@
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
#pragma once
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// C RunTime Header Files
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
// TODO: reference additional headers your program requires here

500
win32/NET/examples/tst_netcdf.vcproj
View File

@ -1,500 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="tst_netcdf"
ProjectGUID="{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}"
RootNamespace="tst_netcdf"
Keyword="ManagedCProj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
ManagedExtensions="4"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG"
MinimalRebuild="false"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
UsePrecompiledHeader="2"
ProgramDataBaseFileName="$(IntDir)/vc70_tst_netcdf.pdb"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
AssemblyDebug="1"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
ManagedExtensions="4"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG"
MinimalRebuild="false"
BasicRuntimeChecks="0"
RuntimeLibrary="3"
UsePrecompiledHeader="2"
ProgramDataBaseFileName="$(IntDir)/vc70_tst_netcdf.pdb"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
AssemblyDebug="1"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
ManagedExtensions="4"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG"
MinimalRebuild="false"
RuntimeLibrary="2"
UsePrecompiledHeader="2"
ProgramDataBaseFileName="$(IntDir)/vc70_tst_netcdf.pdb"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
ManagedExtensions="4"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG"
MinimalRebuild="false"
RuntimeLibrary="2"
UsePrecompiledHeader="2"
ProgramDataBaseFileName="$(IntDir)/vc70_tst_netcdf.pdb"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
<AssemblyReference
RelativePath="mscorlib.dll"
AssemblyName="mscorlib, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=IA64"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.dll"
AssemblyName="System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.Data.dll"
AssemblyName="System.Data, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=x86"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.Drawing.dll"
AssemblyName="System.Drawing, Version=2.0.0.0, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.Windows.Forms.dll"
AssemblyName="System.Windows.Forms, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.XML.dll"
AssemblyName="System.Xml, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\AssemblyInfo.cpp"
>
</File>
<File
RelativePath=".\Form1.cpp"
>
</File>
<File
RelativePath=".\stdafx.cpp"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|x64"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\Form1.h"
FileType="3"
>
<File
RelativePath=".\Form1.resX"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCManagedResourceCompilerTool"
ResourceFileName="$(IntDir)/tst_netcdf.Form1.resources"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|x64"
>
<Tool
Name="VCManagedResourceCompilerTool"
ResourceFileName="$(IntDir)/tst_netcdf.Form1.resources"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCManagedResourceCompilerTool"
ResourceFileName="$(IntDir)/tst_netcdf.Form1.resources"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCManagedResourceCompilerTool"
ResourceFileName="$(IntDir)/tst_netcdf.Form1.resources"
/>
</FileConfiguration>
</File>
</File>
<File
RelativePath=".\resource.h"
>
</File>
<File
RelativePath=".\stdafx.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
<File
RelativePath=".\app.ico"
>
</File>
<File
RelativePath=".\app.rc"
>
</File>
</Filter>
<File
RelativePath=".\ReadMe.txt"
>
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/examples/tst_netcdf.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

57
win32/NET/getopt.c
View File

@ -1,57 +0,0 @@
/*LINTLIBRARY*/
/* This file is here because microsoft doesn't seem to provide
a getopt function. Shame on you, Bill Gates! */
#include <string.h>
#define EOF (-1)
int opterr = 1;
int optind = 1;
int optopt;
char *optarg;
int
getopt(int argc, char *const argv[], const char *opts)
{
static int sp = 1;
register int c;
register char *cp;
if (sp == 1)
if (optind >= argc ||
argv[optind][0] != '-' || argv[optind][1] == '\0')
return (EOF);
else if (strcmp(argv[optind], "--") == 0) {
optind++;
return (EOF);
}
optopt = c = argv[optind][sp];
if (c == ':' || (cp = strchr(opts, c)) == NULL) {
if (argv[optind][++sp] == '\0') {
optind++;
sp = 1;
}
return ('?');
}
if (*++cp == ':') {
if (argv[optind][sp + 1] != '\0')
optarg = &argv[optind++][sp + 1];
else if (++optind >= argc) {
sp = 1;
return ('?');
}
else
optarg = argv[optind++];
sp = 1;
}
else {
if (argv[optind][++sp] == '\0') {
sp = 1;
optind++;
}
optarg = NULL;
}
return (c);
}

305
win32/NET/inttypes.h
View File

@ -1,305 +0,0 @@
// ISO C9x compliant inttypes.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The name of the author may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_INTTYPES_H_ // [
#define _MSC_INTTYPES_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include <stdint.h>
// 7.8 Format conversion of integer types
typedef struct {
intmax_t quot;
intmax_t rem;
} imaxdiv_t;
// 7.8.1 Macros for format specifiers
#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198
// The fprintf macros for signed integers are:
#define PRId8 "d"
#define PRIi8 "i"
#define PRIdLEAST8 "d"
#define PRIiLEAST8 "i"
#define PRIdFAST8 "d"
#define PRIiFAST8 "i"
#define PRId16 "hd"
#define PRIi16 "hi"
#define PRIdLEAST16 "hd"
#define PRIiLEAST16 "hi"
#define PRIdFAST16 "hd"
#define PRIiFAST16 "hi"
#define PRId32 "I32d"
#define PRIi32 "I32i"
#define PRIdLEAST32 "I32d"
#define PRIiLEAST32 "I32i"
#define PRIdFAST32 "I32d"
#define PRIiFAST32 "I32i"
#define PRId64 "I64d"
#define PRIi64 "I64i"
#define PRIdLEAST64 "I64d"
#define PRIiLEAST64 "I64i"
#define PRIdFAST64 "I64d"
#define PRIiFAST64 "I64i"
#define PRIdMAX "I64d"
#define PRIiMAX "I64i"
#define PRIdPTR "Id"
#define PRIiPTR "Ii"
// The fprintf macros for unsigned integers are:
#define PRIo8 "o"
#define PRIu8 "u"
#define PRIx8 "x"
#define PRIX8 "X"
#define PRIoLEAST8 "o"
#define PRIuLEAST8 "u"
#define PRIxLEAST8 "x"
#define PRIXLEAST8 "X"
#define PRIoFAST8 "o"
#define PRIuFAST8 "u"
#define PRIxFAST8 "x"
#define PRIXFAST8 "X"
#define PRIo16 "ho"
#define PRIu16 "hu"
#define PRIx16 "hx"
#define PRIX16 "hX"
#define PRIoLEAST16 "ho"
#define PRIuLEAST16 "hu"
#define PRIxLEAST16 "hx"
#define PRIXLEAST16 "hX"
#define PRIoFAST16 "ho"
#define PRIuFAST16 "hu"
#define PRIxFAST16 "hx"
#define PRIXFAST16 "hX"
#define PRIo32 "I32o"
#define PRIu32 "I32u"
#define PRIx32 "I32x"
#define PRIX32 "I32X"
#define PRIoLEAST32 "I32o"
#define PRIuLEAST32 "I32u"
#define PRIxLEAST32 "I32x"
#define PRIXLEAST32 "I32X"
#define PRIoFAST32 "I32o"
#define PRIuFAST32 "I32u"
#define PRIxFAST32 "I32x"
#define PRIXFAST32 "I32X"
#define PRIo64 "I64o"
#define PRIu64 "I64u"
#define PRIx64 "I64x"
#define PRIX64 "I64X"
#define PRIoLEAST64 "I64o"
#define PRIuLEAST64 "I64u"
#define PRIxLEAST64 "I64x"
#define PRIXLEAST64 "I64X"
#define PRIoFAST64 "I64o"
#define PRIuFAST64 "I64u"
#define PRIxFAST64 "I64x"
#define PRIXFAST64 "I64X"
#define PRIoMAX "I64o"
#define PRIuMAX "I64u"
#define PRIxMAX "I64x"
#define PRIXMAX "I64X"
#define PRIoPTR "Io"
#define PRIuPTR "Iu"
#define PRIxPTR "Ix"
#define PRIXPTR "IX"
// The fscanf macros for signed integers are:
#define SCNd8 "d"
#define SCNi8 "i"
#define SCNdLEAST8 "d"
#define SCNiLEAST8 "i"
#define SCNdFAST8 "d"
#define SCNiFAST8 "i"
#define SCNd16 "hd"
#define SCNi16 "hi"
#define SCNdLEAST16 "hd"
#define SCNiLEAST16 "hi"
#define SCNdFAST16 "hd"
#define SCNiFAST16 "hi"
#define SCNd32 "ld"
#define SCNi32 "li"
#define SCNdLEAST32 "ld"
#define SCNiLEAST32 "li"
#define SCNdFAST32 "ld"
#define SCNiFAST32 "li"
#define SCNd64 "I64d"
#define SCNi64 "I64i"
#define SCNdLEAST64 "I64d"
#define SCNiLEAST64 "I64i"
#define SCNdFAST64 "I64d"
#define SCNiFAST64 "I64i"
#define SCNdMAX "I64d"
#define SCNiMAX "I64i"
#ifdef _WIN64 // [
# define SCNdPTR "I64d"
# define SCNiPTR "I64i"
#else // _WIN64 ][
# define SCNdPTR "ld"
# define SCNiPTR "li"
#endif // _WIN64 ]
// The fscanf macros for unsigned integers are:
#define SCNo8 "o"
#define SCNu8 "u"
#define SCNx8 "x"
#define SCNX8 "X"
#define SCNoLEAST8 "o"
#define SCNuLEAST8 "u"
#define SCNxLEAST8 "x"
#define SCNXLEAST8 "X"
#define SCNoFAST8 "o"
#define SCNuFAST8 "u"
#define SCNxFAST8 "x"
#define SCNXFAST8 "X"
#define SCNo16 "ho"
#define SCNu16 "hu"
#define SCNx16 "hx"
#define SCNX16 "hX"
#define SCNoLEAST16 "ho"
#define SCNuLEAST16 "hu"
#define SCNxLEAST16 "hx"
#define SCNXLEAST16 "hX"
#define SCNoFAST16 "ho"
#define SCNuFAST16 "hu"
#define SCNxFAST16 "hx"
#define SCNXFAST16 "hX"
#define SCNo32 "lo"
#define SCNu32 "lu"
#define SCNx32 "lx"
#define SCNX32 "lX"
#define SCNoLEAST32 "lo"
#define SCNuLEAST32 "lu"
#define SCNxLEAST32 "lx"
#define SCNXLEAST32 "lX"
#define SCNoFAST32 "lo"
#define SCNuFAST32 "lu"
#define SCNxFAST32 "lx"
#define SCNXFAST32 "lX"
#define SCNo64 "I64o"
#define SCNu64 "I64u"
#define SCNx64 "I64x"
#define SCNX64 "I64X"
#define SCNoLEAST64 "I64o"
#define SCNuLEAST64 "I64u"
#define SCNxLEAST64 "I64x"
#define SCNXLEAST64 "I64X"
#define SCNoFAST64 "I64o"
#define SCNuFAST64 "I64u"
#define SCNxFAST64 "I64x"
#define SCNXFAST64 "I64X"
#define SCNoMAX "I64o"
#define SCNuMAX "I64u"
#define SCNxMAX "I64x"
#define SCNXMAX "I64X"
#ifdef _WIN64 // [
# define SCNoPTR "I64o"
# define SCNuPTR "I64u"
# define SCNxPTR "I64x"
# define SCNXPTR "I64X"
#else // _WIN64 ][
# define SCNoPTR "lo"
# define SCNuPTR "lu"
# define SCNxPTR "lx"
# define SCNXPTR "lX"
#endif // _WIN64 ]
#endif // __STDC_FORMAT_MACROS ]
// 7.8.2 Functions for greatest-width integer types
// 7.8.2.1 The imaxabs function
#define imaxabs _abs64
// 7.8.2.2 The imaxdiv function
// This is modified version of div() function from Microsoft's div.c found
// in %MSVC.NET%\crt\src\div.c
#ifdef STATIC_IMAXDIV // [
static
#else // STATIC_IMAXDIV ][
_inline
#endif // STATIC_IMAXDIV ]
imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
{
imaxdiv_t result;
result.quot = numer / denom;
result.rem = numer % denom;
if (numer < 0 && result.rem > 0) {
// did division wrong; must fix up
++result.quot;
result.rem -= denom;
}
return result;
}
// 7.8.2.3 The strtoimax and strtoumax functions
#define strtoimax _strtoi64
#define strtoumax _strtoui64
// 7.8.2.4 The wcstoimax and wcstoumax functions
#define wcstoimax _wcstoi64
#define wcstoumax _wcstoui64
#endif // _MSC_INTTYPES_H_ ]

9
win32/NET/libsrc/Makefile.am
View File

@ -1,9 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
EXTRA_DIST = netcdf.cpp netcdf.vcproj nfconfig.inc stdafx.cpp stdafx.h

21
win32/NET/libsrc/netcdf.cpp
View File

@ -1,21 +0,0 @@
// netcdf.cpp : Defines the entry point for the DLL application.
//
#include "stdafx.h"
#include <netcdf.h>
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}

855
win32/NET/libsrc/netcdf.vcproj
View File

@ -1,855 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="netcdf"
ProjectGUID="{1544CEA3-1365-4482-A719-FF5C14BBAE29}"
RootNamespace="netcdf"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".;&quot;$(SolutionDir)&quot;;..\..\..\libsrc4;..\..\..\libsrc;C:\include"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;NETCDF_EXPORTS;_HDF5USEDLL_;DLL_NETCDF;DLL_EXPORT;VISUAL_CPLUSPLUS;_FILE_OFFSET_BITS=64;NC_DLL_EXPORT;USE_DISPATCH;H5_HAVE_WINDOWS;USE_NETCDF4"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_netcdf.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/netcdf.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="C:\WINDOWS\system32"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/netcdf.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy ..\debug\netcdf.dll ..\vb_wrapper"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".;&quot;$(SolutionDir)&quot;;..\..\..\libsrc4;..\..\..\libsrc;C:\include"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;NETCDF_EXPORTS;_HDF5USEDLL_;DLL_NETCDF;DLL_EXPORT;VISUAL_CPLUSPLUS;_FILE_OFFSET_BITS=64;NC_DLL_EXPORT;USE_DISPATCH;H5_HAVE_WINDOWS;USE_NETCDF4"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_netcdf.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/netcdf.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="C:\WINDOWS\system32"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/netcdf.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy ..\debug\netcdf.dll ..\vb_wrapper"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="&quot;C:\Users\Unidata\netcdf-4.1.3-win-dev\include\hdf5&quot;;&quot;C:\Users\Unidata\netcdf-4.1.3-win-dev\include&quot;;..\..\..\include;.;&quot;$(SolutionDir)&quot;;..;..\..\..\libsrc4;..\..\..\libsrc;..\..\..\libdispatch;..\..\..\libncdap3;..\..\..\oc"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;CURL_STATICLIB;NETCDF_EXPORTS;DLL_NETCDF;DLL_EXPORT;NC_DLL_EXPORT;USE_DISPATCH;H5_HAVE_WINDOWS;USE_NETCDF4"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc90_netcdf.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Ws2_32.lib wsock32.lib advapi32.lib user32.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib sz.lib libcurl.lib libxdr.lib ssleay32.lib libeay32.lib libidn.lib"
OutputFile="$(OutDir)/netcdf.dll"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;C:\Users\Unidata\netcdf-4.1.3-win-dev\lib\x32&quot;;../Release"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary="$(OutDir)/$(TargetName).lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories=".;&quot;$(SolutionDir)&quot;;..;..\..\..\libsrc4;..\..\..\libsrc;..\..\..\libdispatch;..\..\..\libncdap3;..\..\..\oc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;CURL_STATICLIB;NETCDF_EXPORTS;DLL_NETCDF;DLL_EXPORT;NC_DLL_EXPORT;USE_DISPATCH;H5_HAVE_WINDOWS;USE_NETCDF4"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc90_netcdf.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Ws2_32.lib wsock32.lib advapi32.lib user32.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib sz.lib libcurl.lib libxdr.lib ssleay32.lib libeay32.lib libidn.lib"
OutputFile="$(OutDir)/netcdf.dll"
LinkIncremental="1"
AdditionalLibraryDirectories="../Release"
GenerateManifest="false"
GenerateDebugInformation="true"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary="$(OutDir)/$(TargetName).lib"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\netcdf.cpp"
>
</File>
<Filter
Name="libdispatch"
>
<File
RelativePath="..\..\..\libdispatch\att.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\copy.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\dim.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\dispatch.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\error.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\file.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\nc4.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\nc_uri.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\ncbytes.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\nchashmap.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\nclist.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\nclog.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\parallel.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\v2i.c"
>
</File>
<File
RelativePath="..\..\..\libdispatch\var.c"
>
</File>
</Filter>
<Filter
Name="libsrc"
>
<File
RelativePath="..\..\..\libsrc\attr.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\dim3.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\lookup3.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\nc.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\nc3dispatch.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\nclistmgr.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\ncx.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\posixio.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\putget.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\string.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\utf8proc.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\v1hpg.c"
>
</File>
<File
RelativePath="..\..\..\libsrc\var3.c"
>
</File>
</Filter>
<Filter
Name="libsrc4"
>
<File
RelativePath="..\..\..\libsrc4\error4.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4attr.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4dim.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4dispatch.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4file.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4grp.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4hdf.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4internal.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4type.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\nc4var.c"
>
</File>
<File
RelativePath="..\..\..\libsrc4\ncfunc.c"
>
</File>
</Filter>
<Filter
Name="liblib"
>
<File
RelativePath="..\..\..\liblib\stub.c"
>
</File>
</Filter>
<Filter
Name="libdap2"
>
<File
RelativePath="..\..\..\libdap2\cache.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\cdf3.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\cdf4.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\common34.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\constraints3.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\constraints4.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapalign.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapattr3.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapcvt.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapdebug.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapdump.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dapodom.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\daputil.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dceconstraints.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dcelex.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dceparse.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\dcetab.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\getvara3.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\getvara4.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncd3dispatch.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncd4dispatch.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncdap3.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncdap3a.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncdap4.c"
>
</File>
<File
RelativePath="..\..\..\libdap2\ncdaperr.c"
>
</File>
</Filter>
<Filter
Name="oc"
>
<File
RelativePath="..\..\..\oc\curlfunctions.c"
>
</File>
<File
RelativePath="..\..\..\oc\daplex.c"
>
</File>
<File
RelativePath="..\..\..\oc\dapparse.c"
>
</File>
<File
RelativePath="..\..\..\oc\daptab.c"
>
</File>
<File
RelativePath="..\..\..\oc\http.c"
>
</File>
<File
RelativePath="..\..\..\oc\oc.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocbytes.c"
>
</File>
<File
RelativePath="..\..\..\oc\occlientparams.c"
>
</File>
<File
RelativePath="..\..\..\oc\occompile.c"
>
</File>
<File
RelativePath="..\..\..\oc\occontent.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocdata.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocdebug.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocdrno.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocdump.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocinternal.c"
>
</File>
<File
RelativePath="..\..\..\oc\oclist.c"
>
</File>
<File
RelativePath="..\..\..\oc\oclog.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocnode.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocuri.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocutil.c"
>
</File>
<File
RelativePath="..\..\..\oc\ocxdr_stdio.c"
>
</File>
<File
RelativePath="..\..\..\oc\rc.c"
>
</File>
<File
RelativePath="..\..\..\oc\read.c"
>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\config.h"
>
</File>
<File
RelativePath="..\inttypes.h"
>
</File>
<File
RelativePath="..\..\..\include\nc.h"
>
</File>
<File
RelativePath="..\..\..\include\nc3dispatch.h"
>
</File>
<File
RelativePath="..\..\..\include\nc4internal.h"
>
</File>
<File
RelativePath="..\..\..\include\nc_logging.h"
>
</File>
<File
RelativePath="..\..\..\include\nc_tests.h"
>
</File>
<File
RelativePath="..\..\..\include\nc_uri.h"
>
</File>
<File
RelativePath="..\..\..\include\ncaux.h"
>
</File>
<File
RelativePath="..\..\..\include\ncbytes.h"
>
</File>
<File
RelativePath="..\..\..\include\ncconfigure.h"
>
</File>
<File
RelativePath="..\..\..\include\ncdimscale.h"
>
</File>
<File
RelativePath="..\..\..\include\ncdispatch.h"
>
</File>
<File
RelativePath="..\..\..\include\nchashmap.h"
>
</File>
<File
RelativePath="..\..\..\include\ncio.h"
>
</File>
<File
RelativePath="..\..\..\include\nclist.h"
>
</File>
<File
RelativePath="..\..\..\include\nclog.h"
>
</File>
<File
RelativePath="..\..\..\include\nctime.h"
>
</File>
<File
RelativePath="..\..\..\libsrc\ncx.h"
>
</File>
<File
RelativePath="..\..\..\include\netcdf.h"
>
</File>
<File
RelativePath="..\..\..\include\netcdf_par.h"
>
</File>
<File
RelativePath="..\..\..\libsrc\onstack.h"
>
</File>
<File
RelativePath="..\..\..\include\rnd.h"
>
</File>
<File
RelativePath="..\stdint.h"
>
</File>
<File
RelativePath="..\..\..\include\utf8proc.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/libsrc/netcdf.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

83
win32/NET/libsrc/nfconfig.inc
View File

@ -1,83 +0,0 @@
#if 0
$Id: nfconfig.inc,v 1.1 2004/06/09 01:34:17 ed Exp $
#endif
#ifndef UD_NETCDF_CPP_INC
#define UD_NETCDF_CPP_INC
#if 0
Do not have C-style comments in here because this file is processed
by both the FORTRAN compiler (for the nf_test/ stuff) and the C
compiler (for the FORTRAN-callable interface routines) and some
FORTRAN preprocessors do not understand the /*...*/ syntax.
#endif
#if 0
The following macros define the supplementary FORTRAN arithmetic
datatypes beyond the standard INTEGER, REAL, and DOUBLEPRECISION --
ostensibly corresponding to 8-bit and 16-bit integers, respectively.
For example:
#define NF_INT1_T byte
#define NF_INT2_T integer*2
These are the types of the relevant arguments in the NF_*_INT1() and
NF_*_INT2() netCDF FORTRAN function calls. The word "ostensibly"
is used advisedly: on some systems an "integer*2" datatype,
nevertheless, occupies 64 bits (we are not making this up).
If your FORTRAN system does not have the respective supplementary
datatype, then do not define the corresponding macro.
#endif
#define NF_INT1_T byte
#define NF_INT2_T integer*2
#if 0
Define the following NF_*_IS_C_* macros appropriatly for your system.
The "INT1", "INT2" and "INT" after the "NF_" refer to the NF_INT1_T
FORTRAN datatype, the NF_INT2_T FORTRAN datatype, and the INTEGER
FORTRAN datatype, respectively. If the respective FORTRAN datatype
does not exist, then do not define the corresponding macro.
#endif
#define NF_INT1_IS_C_SIGNED_CHAR 1
#undef NF_INT1_IS_C_SHORT
#undef NF_INT1_IS_C_INT
#undef NF_INT1_IS_C_LONG
#define NF_INT2_IS_C_SHORT 1
#undef NF_INT2_IS_C_INT
#undef NF_INT2_IS_C_LONG
#define NF_INT_IS_C_INT 1
#undef NF_INT_IS_C_LONG
#define NF_REAL_IS_C_FLOAT 1
#undef NF_REAL_IS_C_DOUBLE
#define NF_DOUBLEPRECISION_IS_C_DOUBLE 1
#undef NF_DOUBLEPRECISION_IS_C_FLOAT
#if 0
Whether the system uses something besides the IEEE floating-point
format to represent floating-point values.
#endif
#undef NO_IEEE_FLOAT
#if 0
END OF CUSTOMIZATION
#endif
#if 0
FORTRAN data types corresponding to netCDF version 2 "byte" and "short"
data types (e.g. INTEGER*1, INTEGER*2). See file "ftest.F" for usage.
#endif
#if !defined(NO_NETCDF_2)
# define NCBYTE_T byte
# define NCSHORT_T integer*2
#endif
#endif

8
win32/NET/libsrc/stdafx.cpp
View File

@ -1,8 +0,0 @@
// stdafx.cpp : source file that includes just the standard includes
// netcdf.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file

13
win32/NET/libsrc/stdafx.h
View File

@ -1,13 +0,0 @@
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#pragma once
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files:
#include <windows.h>
// TODO: reference additional headers your program requires here

10
win32/NET/nc_test/Makefile.am
View File

@ -1,10 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
EXTRA_DIST = large_files.vcproj nc_test.vcproj \
quick_large_files.vcproj run_tests.bat

377
win32/NET/nc_test/large_files.vcproj
View File

@ -1,377 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="large_files"
ProjectGUID="{9CF427FE-618D-4E27-9610-937A7E0A7524}"
RootNamespace="large_files"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..\libsrc;..;..\..\..\nc_test"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/large_files.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/large_files.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\..\libsrc;..;..\..\..\nc_test"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/large_files.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/large_files.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\..\libsrc;..;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/large_files.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..\..\..\libsrc;..;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/large_files.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\getopt.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\large_files.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\config.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/nc_test/large_files.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

407
win32/NET/nc_test/nc_test.vcproj
View File

@ -1,407 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="nc_test"
ProjectGUID="{849B73F3-0E32-49AA-993E-01AB112F5BF2}"
RootNamespace="nc_test"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nc_test.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nc_test.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/nc_test.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests.bat debug"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nc_test.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nc_test.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/nc_test.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests.bat debug"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nc_test.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nc_test.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nc_test.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nc_test.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\..\nc_test\error.c"
>
</File>
<File
RelativePath="..\getopt.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\nc_test.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\test_get.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\test_put.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\test_read.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\test_write.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\util.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/nc_test/nc_test.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

373
win32/NET/nc_test/quick_large_files.vcproj
View File

@ -1,373 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="quick_large_files"
ProjectGUID="{797D6E0A-0320-41DE-A092-BD562CB88176}"
RootNamespace="quick_large_files"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..;..\..\..\libsrc4;..\..\..\nc_test;\include"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;DLL_NETCDF"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/quick_large_files.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/quick_large_files.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..;..\..\..\libsrc4;..\..\..\nc_test;\include"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;DLL_NETCDF"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/quick_large_files.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/quick_large_files.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..;..\..\..\libsrc4;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/quick_large_files.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="..;..\..\..\libsrc4;..\..\..\nc_test;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/quick_large_files.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\getopt.c"
>
</File>
<File
RelativePath="..\..\..\nc_test\quick_large_files.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/nc_test/quick_large_files.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

7
win32/NET/nc_test/run_tests.bat
View File

@ -1,7 +0,0 @@
echo on
cd ..\%1
rem We need a non-netcdf file called tests.h to pass a test.
rem Here we create one with directory contents, then delete it.
dir > nc_test.o
nc_test
erase nc_test.o

9
win32/NET/ncdump/Makefile.am
View File

@ -1,9 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
EXTRA_DIST = ncdump.vcproj

421
win32/NET/ncdump/ncdump.vcproj
View File

@ -1,421 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="ncdump"
ProjectGUID="{DA7A6115-385C-44AC-B436-E94E95DDCEAC}"
RootNamespace="ncdump"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;USE_NETCDF4"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncdump.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/ncdump.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/ncdump.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;USE_NETCDF4"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncdump.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/ncdump.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/ncdump.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include;..\..\..\oc;..\..\..\libdispatch"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;USE_NETCDF4;CURL_STATICLIB"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncdump.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Ws2_32.lib wsock32.lib advapi32.lib user32.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib sz.lib libcurl.lib libxdr.lib ssleay32.lib libeay32.lib libidn.lib netcdf.lib"
OutputFile="$(OutDir)/ncdump.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;USE_NETCDF4;CURL_STATICLIB"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncdump.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Ws2_32.lib wsock32.lib advapi32.lib user32.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib sz.lib libcurl.lib libxdr.lib ssleay32.lib libeay32.lib libidn.lib netcdf.lib"
OutputFile="$(OutDir)/ncdump.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\..\ncdump\dumplib.c"
>
</File>
<File
RelativePath="..\getopt.c"
>
</File>
<File
RelativePath="..\..\..\ncdump\indent.c"
>
</File>
<File
RelativePath="..\..\..\ncdump\ncdump.c"
>
</File>
<File
RelativePath="..\..\..\ncdump\nctime.c"
>
</File>
<File
RelativePath="..\..\..\ncdump\utils.c"
>
</File>
<File
RelativePath="..\..\..\ncdump\vardata.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\config.h"
>
</File>
<File
RelativePath="..\..\..\ncdump\dumplib.h"
>
</File>
<File
RelativePath="..\..\..\ncdump\indent.h"
>
</File>
<File
RelativePath="..\..\..\ncdump\ncdump.h"
>
</File>
<File
RelativePath="..\..\..\ncdump\vardata.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
<File
RelativePath=".\ReadMe.txt"
>
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/ncdump/ncdump.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

9
win32/NET/ncgen/Makefile.am
View File

@ -1,9 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
EXTRA_DIST = ncgen.cpp ncgen.vcproj run_tests.bat

BIN
win32/NET/ncgen/c0.nc
View File

Binary file not shown.

388
win32/NET/ncgen/c1.cdl
View File

@ -1,388 +0,0 @@
netcdf c1 {
dimensions:
Dr = UNLIMITED ; // (2 currently)
D1 = 1 ;
D2 = 2 ;
D3 = 3 ;
dim-name-dashes = 4 ;
dim.name.dots = 5 ;
dim+name+plusses = 6 ;
dim@name@ats = 7 ;
variables:
char c ;
c:att-name-dashes = 4 ;
c:att.name.dots = 5 ;
c:att+name+plusses = 6 ;
c:att@name@ats = 7 ;
byte b ;
b:c = "" ;
short s ;
s:b = 0b, 127b, -128b, -1b ;
s:s = -32768s, 0s, 32767s ;
int i ;
i:i = -2147483647, 0, 2147483647 ;
i:f = -1.e+036f, 0.f, 1.e+036f ;
i:d = -1.e+308, 0., 1.e+308 ;
float f ;
f:c = "x" ;
double d ;
d:c = "abcd\tZ$&" ;
char cr(Dr) ;
byte br(Dr) ;
short sr(Dr) ;
int ir(Dr) ;
float fr(Dr) ;
double dr(Dr) ;
char c1(D1) ;
byte b1(D1) ;
short s1(D1) ;
int i1(D1) ;
float f1(D1) ;
double d1(D1) ;
char c2(D2) ;
byte b2(D2) ;
short s2(D2) ;
int i2(D2) ;
float f2(D2) ;
double d2(D2) ;
char c3(D3) ;
byte b3(D3) ;
short s3(D3) ;
int i3(D3) ;
float f3(D3) ;
double d3(D3) ;
char cr1(Dr, D1) ;
byte br2(Dr, D2) ;
short sr3(Dr, D3) ;
float f11(D1, D1) ;
double d12(D1, D2) ;
char c13(D1, D3) ;
short s21(D2, D1) ;
int i22(D2, D2) ;
float f23(D2, D3) ;
char c31(D3, D1) ;
byte b32(D3, D2) ;
short s33(D3, D3) ;
short sr11(Dr, D1, D1) ;
int ir12(Dr, D1, D2) ;
float fr13(Dr, D1, D3) ;
char cr21(Dr, D2, D1) ;
byte br22(Dr, D2, D2) ;
short sr23(Dr, D2, D3) ;
float fr31(Dr, D3, D1) ;
double dr32(Dr, D3, D2) ;
char cr33(Dr, D3, D3) ;
char c111(D1, D1, D1) ;
byte b112(D1, D1, D2) ;
short s113(D1, D1, D3) ;
float f121(D1, D2, D1) ;
double d122(D1, D2, D2) ;
char c123(D1, D2, D3) ;
short s131(D1, D3, D1) ;
int i132(D1, D3, D2) ;
float f133(D1, D3, D3) ;
float f211(D2, D1, D1) ;
double d212(D2, D1, D2) ;
char c213(D2, D1, D3) ;
short s221(D2, D2, D1) ;
int i222(D2, D2, D2) ;
float f223(D2, D2, D3) ;
char c231(D2, D3, D1) ;
byte b232(D2, D3, D2) ;
short s233(D2, D3, D3) ;
short s311(D3, D1, D1) ;
int i312(D3, D1, D2) ;
float f313(D3, D1, D3) ;
double var-name-dashes ;
double var.name.dots ;
double var+name+plusses ;
double var@name@ats ;
// global attributes:
:Gc = "" ;
:Gb = -128b, 127b ;
:Gs = -32768s, 0s, 32767s ;
:Gi = -2147483647, 0, 2147483647 ;
:Gf = -1.e+036f, 0.f, 1.e+036f ;
:Gd = -1.e+308, 0., 1.e+308 ;
:Gatt-name-dashes = -1 ;
:Gatt.name.dots = -2 ;
:Gatt+name+plusses = -3 ;
:Gatt@name@ats = -4 ;
data:
c = "2" ;
b = -2 ;
s = -5 ;
i = -20 ;
f = -9 ;
d = -10 ;
cr = "ab" ;
br = -128, 127 ;
sr = -32768, 32767 ;
ir = -2147483646, 2147483647 ;
fr = -1e+036, 1e+036 ;
dr = -1e+308, 1e+308 ;
c1 = "" ;
b1 = -128 ;
s1 = -32768 ;
i1 = -2147483646 ;
f1 = -1e+036 ;
d1 = -1e+308 ;
c2 = "ab" ;
b2 = -128, 127 ;
s2 = -32768, 32767 ;
i2 = -2147483646, 2147483647 ;
f2 = -1e+036, 1e+036 ;
d2 = -1e+308, 1e+308 ;
c3 = "\001\300." ;
b3 = -128, 127, -1 ;
s3 = -32768, 0, 32767 ;
i3 = -2147483646, 0, 2147483647 ;
f3 = -1e+036, 0, 1e+036 ;
d3 = -1e+308, 0, 1e+308 ;
cr1 =
"x",
"y" ;
br2 =
-24, -26,
-20, -22 ;
sr3 =
-375, -380, -385,
-350, -355, -360 ;
f11 =
-2187 ;
d12 =
-3000, -3010 ;
c13 =
"\tb\177" ;
s21 =
-375,
-350 ;
i22 =
-24000, -24020,
-23600, -23620 ;
f23 =
-2187, -2196, -2205,
-2106, -2115, -2124 ;
c31 =
"+",
"-",
" " ;
b32 =
-24, -26,
-20, -22,
-16, -18 ;
s33 =
-375, -380, -385,
-350, -355, -360,
-325, -330, -335 ;
sr11 =
2500,
2375 ;
ir12 =
640000, 639980,
632000, 631980 ;
fr13 =
26244, 26235, 26226,
25515, 25506, 25497 ;
cr21 =
"@",
"D",
"H",
"L" ;
br22 =
64, 62,
68, 66,
56, 54,
60, 58 ;
sr23 =
2500, 2495, 2490,
2525, 2520, 2515,
2375, 2370, 2365,
2400, 2395, 2390 ;
fr31 =
26244,
26325,
26406,
25515,
25596,
25677 ;
dr32 =
40000, 39990,
40100, 40090,
40200, 40190,
39000, 38990,
39100, 39090,
39200, 39190 ;
cr33 =
"1",
"two",
"3",
"4",
"5",
"six" ;
c111 =
"@" ;
b112 =
64, 62 ;
s113 =
2500, 2495, 2490 ;
f121 =
26244,
26325 ;
d122 =
40000, 39990,
40100, 40090 ;
c123 =
"one",
"2" ;
s131 =
2500,
2525,
2550 ;
i132 =
640000, 639980,
640400, 640380,
640800, 640780 ;
f133 =
26244, 26235, 26226,
26325, 26316, 26307,
26406, 26397, 26388 ;
f211 =
26244,
25515 ;
d212 =
40000, 39990,
39000, 38990 ;
c213 =
"",
"" ;
s221 =
2500,
2525,
2375,
2400 ;
i222 =
640000, 639980,
640400, 640380,
632000, 631980,
632400, 632380 ;
f223 =
26244, 26235, 26226,
26325, 26316, 26307,
25515, 25506, 25497,
25596, 25587, 25578 ;
c231 =
"@",
"D",
"H",
"H",
"L",
"P" ;
b232 =
64, 62,
68, 66,
72, 70,
56, 54,
60, 58,
64, 62 ;
s233 =
2500, 2495, 2490,
2525, 2520, 2515,
2550, 2545, 2540,
2375, 2370, 2365,
2400, 2395, 2390,
2425, 2420, 2415 ;
s311 =
2500,
2375,
2250 ;
i312 =
640000, 639980,
632000, 631980,
624000, 623980 ;
f313 =
26244, 26235, 26226,
25515, 25506, 25497,
24786, 24777, 24768 ;
var-name-dashes = -1 ;
var.name.dots = -2 ;
var+name+plusses = _ ;
var@name@ats = _ ;
}

BIN
win32/NET/ncgen/c1.nc
View File

Binary file not shown.

388
win32/NET/ncgen/c2.cdl
View File

@ -1,388 +0,0 @@
netcdf c1 {
dimensions:
Dr = UNLIMITED ; // (2 currently)
D1 = 1 ;
D2 = 2 ;
D3 = 3 ;
dim-name-dashes = 4 ;
dim.name.dots = 5 ;
dim+name+plusses = 6 ;
dim@name@ats = 7 ;
variables:
char c ;
c:att-name-dashes = 4 ;
c:att.name.dots = 5 ;
c:att+name+plusses = 6 ;
c:att@name@ats = 7 ;
byte b ;
b:c = "" ;
short s ;
s:b = 0b, 127b, -128b, -1b ;
s:s = -32768s, 0s, 32767s ;
int i ;
i:i = -2147483647, 0, 2147483647 ;
i:f = -1.e+036f, 0.f, 1.e+036f ;
i:d = -1.e+308, 0., 1.e+308 ;
float f ;
f:c = "x" ;
double d ;
d:c = "abcd\tZ$&" ;
char cr(Dr) ;
byte br(Dr) ;
short sr(Dr) ;
int ir(Dr) ;
float fr(Dr) ;
double dr(Dr) ;
char c1(D1) ;
byte b1(D1) ;
short s1(D1) ;
int i1(D1) ;
float f1(D1) ;
double d1(D1) ;
char c2(D2) ;
byte b2(D2) ;
short s2(D2) ;
int i2(D2) ;
float f2(D2) ;
double d2(D2) ;
char c3(D3) ;
byte b3(D3) ;
short s3(D3) ;
int i3(D3) ;
float f3(D3) ;
double d3(D3) ;
char cr1(Dr, D1) ;
byte br2(Dr, D2) ;
short sr3(Dr, D3) ;
float f11(D1, D1) ;
double d12(D1, D2) ;
char c13(D1, D3) ;
short s21(D2, D1) ;
int i22(D2, D2) ;
float f23(D2, D3) ;
char c31(D3, D1) ;
byte b32(D3, D2) ;
short s33(D3, D3) ;
short sr11(Dr, D1, D1) ;
int ir12(Dr, D1, D2) ;
float fr13(Dr, D1, D3) ;
char cr21(Dr, D2, D1) ;
byte br22(Dr, D2, D2) ;
short sr23(Dr, D2, D3) ;
float fr31(Dr, D3, D1) ;
double dr32(Dr, D3, D2) ;
char cr33(Dr, D3, D3) ;
char c111(D1, D1, D1) ;
byte b112(D1, D1, D2) ;
short s113(D1, D1, D3) ;
float f121(D1, D2, D1) ;
double d122(D1, D2, D2) ;
char c123(D1, D2, D3) ;
short s131(D1, D3, D1) ;
int i132(D1, D3, D2) ;
float f133(D1, D3, D3) ;
float f211(D2, D1, D1) ;
double d212(D2, D1, D2) ;
char c213(D2, D1, D3) ;
short s221(D2, D2, D1) ;
int i222(D2, D2, D2) ;
float f223(D2, D2, D3) ;
char c231(D2, D3, D1) ;
byte b232(D2, D3, D2) ;
short s233(D2, D3, D3) ;
short s311(D3, D1, D1) ;
int i312(D3, D1, D2) ;
float f313(D3, D1, D3) ;
double var-name-dashes ;
double var.name.dots ;
double var+name+plusses ;
double var@name@ats ;
// global attributes:
:Gc = "" ;
:Gb = -128b, 127b ;
:Gs = -32768s, 0s, 32767s ;
:Gi = -2147483647, 0, 2147483647 ;
:Gf = -1.e+036f, 0.f, 1.e+036f ;
:Gd = -1.e+308, 0., 1.e+308 ;
:Gatt-name-dashes = -1 ;
:Gatt.name.dots = -2 ;
:Gatt+name+plusses = -3 ;
:Gatt@name@ats = -4 ;
data:
c = "2" ;
b = -2 ;
s = -5 ;
i = -20 ;
f = -9 ;
d = -10 ;
cr = "ab" ;
br = -128, 127 ;
sr = -32768, 32767 ;
ir = -2147483646, 2147483647 ;
fr = -1e+036, 1e+036 ;
dr = -1e+308, 1e+308 ;
c1 = "" ;
b1 = -128 ;
s1 = -32768 ;
i1 = -2147483646 ;
f1 = -1e+036 ;
d1 = -1e+308 ;
c2 = "ab" ;
b2 = -128, 127 ;
s2 = -32768, 32767 ;
i2 = -2147483646, 2147483647 ;
f2 = -1e+036, 1e+036 ;
d2 = -1e+308, 1e+308 ;
c3 = "\001\300." ;
b3 = -128, 127, -1 ;
s3 = -32768, 0, 32767 ;
i3 = -2147483646, 0, 2147483647 ;
f3 = -1e+036, 0, 1e+036 ;
d3 = -1e+308, 0, 1e+308 ;
cr1 =
"x",
"y" ;
br2 =
-24, -26,
-20, -22 ;
sr3 =
-375, -380, -385,
-350, -355, -360 ;
f11 =
-2187 ;
d12 =
-3000, -3010 ;
c13 =
"\tb\177" ;
s21 =
-375,
-350 ;
i22 =
-24000, -24020,
-23600, -23620 ;
f23 =
-2187, -2196, -2205,
-2106, -2115, -2124 ;
c31 =
"+",
"-",
" " ;
b32 =
-24, -26,
-20, -22,
-16, -18 ;
s33 =
-375, -380, -385,
-350, -355, -360,
-325, -330, -335 ;
sr11 =
2500,
2375 ;
ir12 =
640000, 639980,
632000, 631980 ;
fr13 =
26244, 26235, 26226,
25515, 25506, 25497 ;
cr21 =
"@",
"D",
"H",
"L" ;
br22 =
64, 62,
68, 66,
56, 54,
60, 58 ;
sr23 =
2500, 2495, 2490,
2525, 2520, 2515,
2375, 2370, 2365,
2400, 2395, 2390 ;
fr31 =
26244,
26325,
26406,
25515,
25596,
25677 ;
dr32 =
40000, 39990,
40100, 40090,
40200, 40190,
39000, 38990,
39100, 39090,
39200, 39190 ;
cr33 =
"1",
"two",
"3",
"4",
"5",
"six" ;
c111 =
"@" ;
b112 =
64, 62 ;
s113 =
2500, 2495, 2490 ;
f121 =
26244,
26325 ;
d122 =
40000, 39990,
40100, 40090 ;
c123 =
"one",
"2" ;
s131 =
2500,
2525,
2550 ;
i132 =
640000, 639980,
640400, 640380,
640800, 640780 ;
f133 =
26244, 26235, 26226,
26325, 26316, 26307,
26406, 26397, 26388 ;
f211 =
26244,
25515 ;
d212 =
40000, 39990,
39000, 38990 ;
c213 =
"",
"" ;
s221 =
2500,
2525,
2375,
2400 ;
i222 =
640000, 639980,
640400, 640380,
632000, 631980,
632400, 632380 ;
f223 =
26244, 26235, 26226,
26325, 26316, 26307,
25515, 25506, 25497,
25596, 25587, 25578 ;
c231 =
"@",
"D",
"H",
"H",
"L",
"P" ;
b232 =
64, 62,
68, 66,
72, 70,
56, 54,
60, 58,
64, 62 ;
s233 =
2500, 2495, 2490,
2525, 2520, 2515,
2550, 2545, 2540,
2375, 2370, 2365,
2400, 2395, 2390,
2425, 2420, 2415 ;
s311 =
2500,
2375,
2250 ;
i312 =
640000, 639980,
632000, 631980,
624000, 623980 ;
f313 =
26244, 26235, 26226,
25515, 25506, 25497,
24786, 24777, 24768 ;
var-name-dashes = -1 ;
var.name.dots = -2 ;
var+name+plusses = _ ;
var@name@ats = _ ;
}

10
win32/NET/ncgen/ncgen.cpp
View File

@ -1,10 +0,0 @@
// ncgen.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}

505
win32/NET/ncgen/ncgen.vcproj
View File

@ -1,505 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="ncgen"
ProjectGUID="{81623E8F-4575-429E-9EA1-BFFAC1E253F7}"
RootNamespace="ncgen"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;USE_NETCDF4;USE_DISPATCH"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncgen.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/ncgen.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/ncgen.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests debug"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;USE_NETCDF4;USE_DISPATCH"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_ncgen.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/ncgen.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/ncgen.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests debug"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;USE_NETCDF4;USE_DISPATCH;HAVE_STRDUP"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc90_ncgen.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/ncgen.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;USE_NETCDF4;USE_DISPATCH;HAVE_STRDUP"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc90_ncgen.pdb"
WarningLevel="1"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib hdf5_hldll.lib hdf5dll.lib zlib1.lib"
OutputFile="$(OutDir)/ncgen.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="false"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\..\ncgen\bindata.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\bytebuffer.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\cdata.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\ConvertUTF.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\cvt.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\data.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\debug.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\dump.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\escapes.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\f77data.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genbin.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genc.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genchar.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\generr.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genf77.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genj.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\genlib.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\getfill.c"
>
</File>
<File
RelativePath="..\getopt.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\jdata.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\list.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\main.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\ncgentab.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\nciter.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\odom.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\offsets.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\semantics.c"
>
</File>
<File
RelativePath="..\..\..\ncgen\util.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\..\..\ncgen\generic.h"
>
</File>
<File
RelativePath="..\..\..\ncgen\genlib.h"
>
</File>
<File
RelativePath="..\..\..\ncgen\ncgen.h"
>
</File>
<File
RelativePath="..\..\..\ncgen\ncgentab.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/ncgen/ncgen.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

20
win32/NET/ncgen/run_tests.bat
View File

@ -1,20 +0,0 @@
:: Runs ncgen and ncdump tests.
echo on
..\%1\ncgen -b -o c0.nc ..\..\..\ncgen\c0.cdl
..\%1\ncdump -n c1 c0.nc > c1.cdl
..\%1\ncgen -b c1.cdl
..\%1\ncdump c1.nc > c2.cdl
fc c1.cdl c2.cdl | find /i "FC: no differences encountered" > nul
if errorlevel==1 goto ERR_LABEL
..\%1\ncgen -b ..\..\..\ncdump\test0.cdl
..\%1\ncdump -n test1 test0.nc > test1.cdl
..\%1\ncgen -b test1.cdl
..\%1\ncdump test1.nc > test2.cdl
fc test1.cdl test2.cdl | find /i "FC: no differences encountered" > nul
if errorlevel==1 goto ERR_LABEL
exit \B 0
:ERR_LABEL
echo ************** ERROR - Comparison Not Correct! **********************
exit \B 1

0
win32/NET/ncgen/test1.cdl
View File

0
win32/NET/ncgen/test2.cdl
View File

9
win32/NET/nctest/Makefile.am
View File

@ -1,9 +0,0 @@
## This is a automake file, part of Unidata's netCDF package.
# Copyright 2007, see the COPYRIGHT file for more information.
# This is to include the .NET build files.
# $Id: Makefile.am,v 1.1 2007/04/25 15:57:09 ed Exp $
EXTRA_DIST = nctest.vcproj run_tests.bat

461
win32/NET/nctest/nctest.vcproj
View File

@ -1,461 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="nctest"
ProjectGUID="{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}"
RootNamespace="nctest"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;DLL_NETCDF"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nctest.pdb"
WarningLevel="2"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nctest.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/nctest.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests debug"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;DLL_NETCDF"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nctest.pdb"
WarningLevel="2"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nctest.exe"
LinkIncremental="2"
AdditionalLibraryDirectories="..\Debug"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/nctest.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests debug"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;DLL_NETCDF"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nctest.pdb"
WarningLevel="2"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nctest.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TargetEnvironment="3"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(SolutionDir);..\..\..\libsrc4;..\..\..\libsrc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;DLL_NETCDF"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
ProgramDataBaseFileName="$(IntDir)/vc70_nctest.pdb"
WarningLevel="2"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
OutputFile="$(OutDir)/nctest.exe"
LinkIncremental="1"
AdditionalLibraryDirectories="..\Release"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="run_tests release"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\..\nctest\add.c"
>
</File>
<File
RelativePath="..\..\..\nctest\atttests.c"
>
</File>
<File
RelativePath="..\..\..\nctest\cdftests.c"
>
</File>
<File
RelativePath="..\..\..\nctest\dimtests.c"
>
</File>
<File
RelativePath="..\..\..\nctest\driver.c"
>
</File>
<File
RelativePath="..\..\..\nctest\emalloc.c"
>
</File>
<File
RelativePath="..\..\..\nctest\error.c"
>
</File>
<File
RelativePath="..\..\..\nctest\misctest.c"
>
</File>
<File
RelativePath="..\..\..\nctest\rec.c"
>
</File>
<File
RelativePath="..\..\..\nctest\slabs.c"
>
</File>
<File
RelativePath="..\..\..\nctest\val.c"
>
</File>
<File
RelativePath="..\..\..\nctest\vardef.c"
>
</File>
<File
RelativePath="..\..\..\nctest\varget.c"
>
</File>
<File
RelativePath="..\..\..\nctest\vargetg.c"
>
</File>
<File
RelativePath="..\..\..\nctest\varput.c"
>
</File>
<File
RelativePath="..\..\..\nctest\varputg.c"
>
</File>
<File
RelativePath="..\..\..\nctest\vartests.c"
>
</File>
<File
RelativePath="..\..\..\nctest\vputget.c"
>
</File>
<File
RelativePath="..\..\..\nctest\vputgetg.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\..\..\nctest\add.h"
>
</File>
<File
RelativePath="..\..\..\nctest\emalloc.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

121
win32/NET/nctest/nctest.vcproj.Unidata-PC.Unidata.user
View File

@ -1,121 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9.00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Debug|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|x64"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="UNIDATA-PC"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

BIN
win32/NET/nctest/nctest_64bit_offset.nc
View File

Binary file not shown.

BIN
win32/NET/nctest/nctest_classic.nc
View File

Binary file not shown.

BIN
win32/NET/nctest/nctest_netcdf4.nc
View File

Binary file not shown.

13
win32/NET/nctest/run_tests.bat
View File

@ -1,13 +0,0 @@
echo on
rem We need a non-netcdf file called driver.c to pass a test.
rem Here we create one with directory contents, then delete it.
dir > driver.o
..\%1\nctest
rem fc testfile.nc ..\..\..\nctest\testfile_nc.sav | find /i "FC: no differences encountered" > nul
rem if errorlevel==1 goto ERR_LABEL
erase driver.o
exit \B 0
:ERR_LABEL
echo ************** ERROR - Comparison Not Correct! **********************
exit \B 1

BIN
win32/NET/nctest/temp.tmp
View File

Binary file not shown.

BIN
win32/NET/nctest/test2.nc
View File

Binary file not shown.

137
win32/NET/netcdf.sln
View File

@ -1,137 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "netcdf", "libsrc\netcdf.vcproj", "{1544CEA3-1365-4482-A719-FF5C14BBAE29}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nctest", "nctest\nctest.vcproj", "{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}"
ProjectSection(ProjectDependencies) = postProject
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{81623E8F-4575-429E-9EA1-BFFAC1E253F7} = {81623E8F-4575-429E-9EA1-BFFAC1E253F7}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
{849B73F3-0E32-49AA-993E-01AB112F5BF2} = {849B73F3-0E32-49AA-993E-01AB112F5BF2}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nc_test", "nc_test\nc_test.vcproj", "{849B73F3-0E32-49AA-993E-01AB112F5BF2}"
ProjectSection(ProjectDependencies) = postProject
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{81623E8F-4575-429E-9EA1-BFFAC1E253F7} = {81623E8F-4575-429E-9EA1-BFFAC1E253F7}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ncdump", "ncdump\ncdump.vcproj", "{DA7A6115-385C-44AC-B436-E94E95DDCEAC}"
ProjectSection(ProjectDependencies) = postProject
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ncgen", "ncgen\ncgen.vcproj", "{81623E8F-4575-429E-9EA1-BFFAC1E253F7}"
ProjectSection(ProjectDependencies) = postProject
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tst_netcdf", "examples\tst_netcdf.vcproj", "{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}"
ProjectSection(ProjectDependencies) = postProject
{797D6E0A-0320-41DE-A092-BD562CB88176} = {797D6E0A-0320-41DE-A092-BD562CB88176}
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4} = {16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}
{81623E8F-4575-429E-9EA1-BFFAC1E253F7} = {81623E8F-4575-429E-9EA1-BFFAC1E253F7}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
{849B73F3-0E32-49AA-993E-01AB112F5BF2} = {849B73F3-0E32-49AA-993E-01AB112F5BF2}
{9CF427FE-618D-4E27-9610-937A7E0A7524} = {9CF427FE-618D-4E27-9610-937A7E0A7524}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "large_files", "nc_test\large_files.vcproj", "{9CF427FE-618D-4E27-9610-937A7E0A7524}"
ProjectSection(ProjectDependencies) = postProject
{797D6E0A-0320-41DE-A092-BD562CB88176} = {797D6E0A-0320-41DE-A092-BD562CB88176}
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4} = {16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}
{81623E8F-4575-429E-9EA1-BFFAC1E253F7} = {81623E8F-4575-429E-9EA1-BFFAC1E253F7}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
{849B73F3-0E32-49AA-993E-01AB112F5BF2} = {849B73F3-0E32-49AA-993E-01AB112F5BF2}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "quick_large_files", "nc_test\quick_large_files.vcproj", "{797D6E0A-0320-41DE-A092-BD562CB88176}"
ProjectSection(ProjectDependencies) = postProject
{DA7A6115-385C-44AC-B436-E94E95DDCEAC} = {DA7A6115-385C-44AC-B436-E94E95DDCEAC}
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4} = {16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}
{81623E8F-4575-429E-9EA1-BFFAC1E253F7} = {81623E8F-4575-429E-9EA1-BFFAC1E253F7}
{1544CEA3-1365-4482-A719-FF5C14BBAE29} = {1544CEA3-1365-4482-A719-FF5C14BBAE29}
{849B73F3-0E32-49AA-993E-01AB112F5BF2} = {849B73F3-0E32-49AA-993E-01AB112F5BF2}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Debug|Win32.ActiveCfg = Debug|Win32
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Debug|Win32.Build.0 = Debug|Win32
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Debug|x64.ActiveCfg = Debug|x64
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Debug|x64.Build.0 = Debug|x64
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Release|Win32.ActiveCfg = Release|Win32
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Release|Win32.Build.0 = Release|Win32
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Release|x64.ActiveCfg = Release|x64
{1544CEA3-1365-4482-A719-FF5C14BBAE29}.Release|x64.Build.0 = Release|x64
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Debug|Win32.ActiveCfg = Debug|Win32
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Debug|Win32.Build.0 = Debug|Win32
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Debug|x64.ActiveCfg = Debug|x64
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Debug|x64.Build.0 = Debug|x64
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Release|Win32.ActiveCfg = Release|Win32
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Release|Win32.Build.0 = Release|Win32
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Release|x64.ActiveCfg = Release|x64
{16F8E55F-8CFB-412F-80F0-DEBDEAE068A4}.Release|x64.Build.0 = Release|x64
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Debug|Win32.ActiveCfg = Debug|Win32
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Debug|Win32.Build.0 = Debug|Win32
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Debug|x64.ActiveCfg = Debug|x64
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Debug|x64.Build.0 = Debug|x64
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Release|Win32.ActiveCfg = Release|Win32
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Release|Win32.Build.0 = Release|Win32
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Release|x64.ActiveCfg = Release|x64
{849B73F3-0E32-49AA-993E-01AB112F5BF2}.Release|x64.Build.0 = Release|x64
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Debug|Win32.ActiveCfg = Debug|Win32
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Debug|Win32.Build.0 = Debug|Win32
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Debug|x64.ActiveCfg = Debug|x64
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Debug|x64.Build.0 = Debug|x64
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Release|Win32.ActiveCfg = Release|Win32
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Release|Win32.Build.0 = Release|Win32
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Release|x64.ActiveCfg = Release|x64
{DA7A6115-385C-44AC-B436-E94E95DDCEAC}.Release|x64.Build.0 = Release|x64
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Debug|Win32.ActiveCfg = Debug|Win32
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Debug|Win32.Build.0 = Debug|Win32
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Debug|x64.ActiveCfg = Debug|x64
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Debug|x64.Build.0 = Debug|x64
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Release|Win32.ActiveCfg = Release|Win32
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Release|Win32.Build.0 = Release|Win32
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Release|x64.ActiveCfg = Release|x64
{81623E8F-4575-429E-9EA1-BFFAC1E253F7}.Release|x64.Build.0 = Release|x64
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Debug|Win32.ActiveCfg = Debug|Win32
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Debug|Win32.Build.0 = Debug|Win32
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Debug|x64.ActiveCfg = Debug|x64
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Debug|x64.Build.0 = Debug|x64
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Release|Win32.ActiveCfg = Release|Win32
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Release|Win32.Build.0 = Release|Win32
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Release|x64.ActiveCfg = Release|x64
{E1F00190-5DE7-4333-9AB9-E4EBB9EB6139}.Release|x64.Build.0 = Release|x64
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Debug|Win32.ActiveCfg = Debug|Win32
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Debug|Win32.Build.0 = Debug|Win32
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Debug|x64.ActiveCfg = Debug|x64
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Debug|x64.Build.0 = Debug|x64
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Release|Win32.ActiveCfg = Release|Win32
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Release|Win32.Build.0 = Release|Win32
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Release|x64.ActiveCfg = Release|x64
{9CF427FE-618D-4E27-9610-937A7E0A7524}.Release|x64.Build.0 = Release|x64
{797D6E0A-0320-41DE-A092-BD562CB88176}.Debug|Win32.ActiveCfg = Debug|Win32
{797D6E0A-0320-41DE-A092-BD562CB88176}.Debug|Win32.Build.0 = Debug|Win32
{797D6E0A-0320-41DE-A092-BD562CB88176}.Debug|x64.ActiveCfg = Debug|x64
{797D6E0A-0320-41DE-A092-BD562CB88176}.Debug|x64.Build.0 = Debug|x64
{797D6E0A-0320-41DE-A092-BD562CB88176}.Release|Win32.ActiveCfg = Release|Win32
{797D6E0A-0320-41DE-A092-BD562CB88176}.Release|Win32.Build.0 = Release|Win32
{797D6E0A-0320-41DE-A092-BD562CB88176}.Release|x64.ActiveCfg = Release|x64
{797D6E0A-0320-41DE-A092-BD562CB88176}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

263
win32/NET/netcdff/netcdff.vcproj
View File

@ -1,263 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="netcdff"
ProjectGUID="{B4A86F41-9EE0-4E6E-BA35-6075BD3FE86F}"
RootNamespace="netcdff"
Keyword="Win32Proj"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
CharacterSet="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;NETCDFF_EXPORTS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
LinkIncremental="2"
GenerateDebugInformation="true"
SubSystem="2"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
CharacterSet="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
EnableIntrinsicFunctions="true"
AdditionalIncludeDirectories=".;&quot;$(SolutionDir)&quot;;..;..\..\..\libsrc4;..\..\..\libsrc;..\..\..\libdispatch;..\..\..\libncdap3;..\..\..\fortran;..\..\..\oc;..\..\..\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;CURL_STATICLIB;DLL_EXPORT;VISUAL_CPLUSPLUS;USE_NETCDF4;USE_DISPATCH;HAVE_STRDUP;USE_DISPATCH;H5_HAVE_WINDOWS;USE_NETCDF4"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="netcdf.lib"
LinkIncremental="1"
GenerateDebugInformation="false"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\..\fortran\fort-attio.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-control.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-dim.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-genatt.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-geninq.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-genvar.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-lib.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-lib.h"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-misc.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-nc4.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-v2compat.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-var1io.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-varaio.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-vario.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-varmio.c"
>
</File>
<File
RelativePath="..\..\..\fortran\fort-varsio.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\..\..\fortran\cfortran.h"
>
</File>
<File
RelativePath="..\..\..\fortran\ncfortran.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

232
win32/NET/stdint.h
View File

@ -1,232 +0,0 @@
// ISO C9x compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006-2008 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The name of the author may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_STDINT_H_ // [
#define _MSC_STDINT_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include <limits.h>
// For Visual Studio 6 in C++ mode wrap <wchar.h> include with 'extern "C++" {}'
// or compiler give many errors like this:
// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
#if (_MSC_VER < 1300) && defined(__cplusplus)
extern "C++" {
#endif
# include <wchar.h>
#if (_MSC_VER < 1300) && defined(__cplusplus)
}
#endif
// Define _W64 macros to mark types changing their size, like intptr_t.
#ifndef _W64
# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
# define _W64 __w64
# else
# define _W64
# endif
#endif
// 7.18.1 Integer types
// 7.18.1.1 Exact-width integer types
typedef __int8 int8_t;
typedef __int16 int16_t;
typedef __int32 int32_t;
typedef __int64 int64_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
// 7.18.1.2 Minimum-width integer types
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
// 7.18.1.3 Fastest minimum-width integer types
typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
// 7.18.1.4 Integer types capable of holding object pointers
#ifdef _WIN64 // [
typedef __int64 intptr_t;
typedef unsigned __int64 uintptr_t;
#else // _WIN64 ][
typedef _W64 int intptr_t;
typedef _W64 unsigned int uintptr_t;
#endif // _WIN64 ]
// 7.18.1.5 Greatest-width integer types
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
// 7.18.2 Limits of specified-width integer types
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
// 7.18.2.1 Limits of exact-width integer types
#define INT8_MIN ((int8_t)_I8_MIN)
#define INT8_MAX _I8_MAX
#define INT16_MIN ((int16_t)_I16_MIN)
#define INT16_MAX _I16_MAX
#define INT32_MIN ((int32_t)_I32_MIN)
#define INT32_MAX _I32_MAX
#define INT64_MIN ((int64_t)_I64_MIN)
#define INT64_MAX _I64_MAX
#define UINT8_MAX _UI8_MAX
#define UINT16_MAX _UI16_MAX
#define UINT32_MAX _UI32_MAX
#define UINT64_MAX _UI64_MAX
// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
// 7.18.2.3 Limits of fastest minimum-width integer types
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST16_MIN INT16_MIN
#define INT_FAST16_MAX INT16_MAX
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST16_MAX UINT16_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define UINT_FAST64_MAX UINT64_MAX
// 7.18.2.4 Limits of integer types capable of holding object pointers
#ifdef _WIN64 // [
# define INTPTR_MIN INT64_MIN
# define INTPTR_MAX INT64_MAX
# define UINTPTR_MAX UINT64_MAX
#else // _WIN64 ][
# define INTPTR_MIN INT32_MIN
# define INTPTR_MAX INT32_MAX
# define UINTPTR_MAX UINT32_MAX
#endif // _WIN64 ]
// 7.18.2.5 Limits of greatest-width integer types
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
// 7.18.3 Limits of other integer types
#ifdef _WIN64 // [
# define PTRDIFF_MIN _I64_MIN
# define PTRDIFF_MAX _I64_MAX
#else // _WIN64 ][
# define PTRDIFF_MIN _I32_MIN
# define PTRDIFF_MAX _I32_MAX
#endif // _WIN64 ]
#define SIG_ATOMIC_MIN INT_MIN
#define SIG_ATOMIC_MAX INT_MAX
#ifndef SIZE_MAX // [
# ifdef _WIN64 // [
# define SIZE_MAX _UI64_MAX
# else // _WIN64 ][
# define SIZE_MAX _UI32_MAX
# endif // _WIN64 ]
#endif // SIZE_MAX ]
// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
#ifndef WCHAR_MIN // [
# define WCHAR_MIN 0
#endif // WCHAR_MIN ]
#ifndef WCHAR_MAX // [
# define WCHAR_MAX _UI16_MAX
#endif // WCHAR_MAX ]
#define WINT_MIN 0
#define WINT_MAX _UI16_MAX
#endif // __STDC_LIMIT_MACROS ]
// 7.18.4 Limits of other integer types
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
// 7.18.4.1 Macros for minimum-width integer constants
#define INT8_C(val) val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64
#define UINT8_C(val) val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64
// 7.18.4.2 Macros for greatest-width integer constants
#define INTMAX_C INT64_C
#define UINTMAX_C UINT64_C
#endif // __STDC_CONSTANT_MACROS ]
#endif // _MSC_STDINT_H_ ]