mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-12-21 08:39:46 +08:00
835b81a285
NOTE: This PR should not be included in 4.9.1 since additional DAP4 related PRs will be forthcoming. This PR makes major changes to libdap4 and dap4_test driven by changes to TDS. * Enable DAP4 * Clean up the test input files and the test baseline comparison files. This entails: * Remove a multitude of unused test input and baseline data files; among them are dap4_test/: daptestfiles, dmrtestfiles, nctestfiles, and misctestfiles. * Define a canonical set of test input files and record in dap4_test/cdltestfiles. * Use the cdltestfiles to generate the .nc test inputs. This set of .nc files is then moved to the d4ts (DAP4 test server) war file in the tds repository. This set then becomes the canonical set of DAP4 test sources. * Scrape d4ts to obtain copies of the raw streams of DAP4 encoded data. The .dmr and .dap streams are then stored in dap4_test/rawtestfiles. * Disable some remote server tests until those servers are fixed. * Add an option to ncdump (-XF) that forces the type of the _FillValue attribute; this is primarily to simplify testing of fill mismatch. * Minor bug fixes to ncgen. * Changes to libdap4: * Replace old checksum hack with the dap4.checksum flag. * Support the dap4.XXX controls. * Cleanup _FillValue handling, especially var-attribute type mismatches. * Fix enum handling based on changes to netcdf-java. * Changes to dap4_test: * Add getopt support to various test support programs. * Remove unneeded shell scripts. * Add new scripts: test_curlopt.sh
164 lines
4.3 KiB
C
164 lines
4.3 KiB
C
/*********************************************************************
|
|
* Copyright 2018, UCAR/Unidata
|
|
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
|
|
*********************************************************************/
|
|
#include "config.h"
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#include "d4includes.h"
|
|
#include "ncdispatch.h"
|
|
#include "netcdf_aux.h"
|
|
|
|
#ifdef D4CATCH
|
|
/* Place breakpoint here to catch errors close to where they occur*/
|
|
int
|
|
d4breakpoint(int err) {
|
|
return err;
|
|
}
|
|
|
|
int
|
|
d4throw(int err)
|
|
{
|
|
if(err == 0) return err;
|
|
return d4breakpoint(err);
|
|
}
|
|
#endif
|
|
|
|
int
|
|
d4panic(const char* fmt, ...)
|
|
{
|
|
va_list args;
|
|
if(fmt != NULL) {
|
|
va_start(args, fmt);
|
|
vfprintf(stderr, fmt, args);
|
|
fprintf(stderr, "\n" );
|
|
va_end( args );
|
|
} else {
|
|
fprintf(stderr, "panic" );
|
|
}
|
|
fprintf(stderr, "\n" );
|
|
fflush(stderr);
|
|
return 0;
|
|
}
|
|
|
|
const char*
|
|
NCD4_sortname(NCD4sort sort)
|
|
{
|
|
switch (sort) {
|
|
case NCD4_NULL: return "NCD4_NULL";
|
|
case NCD4_ATTR: return "NCD4_ATTR";
|
|
case NCD4_ATTRSET: return "NCD4_ATTRSET";
|
|
case NCD4_XML: return "NCD4_XML";
|
|
case NCD4_DIM: return "NCD4_DIM";
|
|
case NCD4_GROUP: return "NCD4_GROUP";
|
|
case NCD4_TYPE: return "NCD4_TYPE";
|
|
case NCD4_VAR: return "NCD4_VAR";
|
|
case NCD4_ECONST: return "NCD4_ECONST";
|
|
default: break;
|
|
}
|
|
return "sort.unknown";
|
|
}
|
|
|
|
const char*
|
|
NCD4_subsortname(nc_type subsort)
|
|
{
|
|
switch (subsort) {
|
|
case NC_NAT: return "NC_NAT";
|
|
case NC_BYTE: return "NC_BYTE";
|
|
case NC_CHAR: return "NC_CHAR";
|
|
case NC_SHORT: return "NC_SHORT";
|
|
case NC_INT: return "NC_INT";
|
|
case NC_FLOAT: return "NC_FLOAT";
|
|
case NC_DOUBLE: return "NC_DOUBLE";
|
|
case NC_UBYTE: return "NC_UBYTE";
|
|
case NC_USHORT: return "NC_USHORT";
|
|
case NC_UINT: return "NC_UINT";
|
|
case NC_INT64: return "NC_INT64";
|
|
case NC_UINT64: return "NC_UINT64";
|
|
case NC_STRING: return "NC_STRING";
|
|
case NC_VLEN: return "NC_SEQ";
|
|
case NC_OPAQUE: return "NC_OPAQUE";
|
|
case NC_ENUM: return "NC_ENUM";
|
|
case NC_COMPOUND: return "NC_STRUCT";
|
|
default: break;
|
|
}
|
|
return "subsort.unknown";
|
|
}
|
|
|
|
/*
|
|
For debugging purposes, it is desirable to fake an nccopy
|
|
bv inserting the data into the substrate and then writing it out.
|
|
*/
|
|
|
|
int
|
|
NCD4_debugcopy(NCD4INFO* info)
|
|
{
|
|
int i,ret=NC_NOERR;
|
|
NCD4meta* meta = info->substrate.metadata;
|
|
NClist* topvars = nclistnew();
|
|
NC* ncp = info->controller;
|
|
void* memory = NULL;
|
|
|
|
/* Walk each top level variable, read all of it and write it to the substrate */
|
|
if((ret=NCD4_getToplevelVars(meta, NULL, topvars)))
|
|
goto done;
|
|
/* Read from the dap data by going thru the dap4 interface */
|
|
for(i=0;i<nclistlength(topvars);i++) {
|
|
NCD4node* var = nclistget(topvars,i);
|
|
NCD4node* type = var->basetype;
|
|
NCD4node* grp = NCD4_groupFor(var);
|
|
int grpid = grp->meta.id;
|
|
int varid = var->meta.id;
|
|
d4size_t varsize;
|
|
size_t dimprod = NCD4_dimproduct(var);
|
|
int ncid = info->substrate.nc4id;
|
|
|
|
varsize = type->meta.memsize * dimprod;
|
|
memory = d4alloc(varsize);
|
|
if(memory == NULL)
|
|
{ret = NC_ENOMEM; goto done;}
|
|
{
|
|
/* We need to read via NCD4 */
|
|
int d4gid = makedap4id(ncp,grpid);
|
|
if((ret=nc_get_var(d4gid,varid,memory)))
|
|
goto done;
|
|
}
|
|
/* Now, turn around and write it to the substrate.
|
|
WARNING: we have to specify the shape ourselves
|
|
because, if unlimited is involved then there is
|
|
potentially a difference between the substrate unlimited
|
|
size and the dap4 data specified size. In fact,
|
|
the substrate will always be zero unless debugcopy is used.
|
|
*/
|
|
{
|
|
size_t edges[NC_MAX_VAR_DIMS];
|
|
int d;
|
|
for(d=0;d<nclistlength(var->dims);d++) {
|
|
NCD4node* dim = (NCD4node*)nclistget(var->dims,d);
|
|
edges[d] = (size_t)dim->dim.size;
|
|
}
|
|
if((ret=nc_put_vara(grpid,varid,NC_coord_zero,edges,memory)))
|
|
goto done;
|
|
}
|
|
if((ret=ncaux_reclaim_data(ncid,type->meta.id,memory,dimprod)))
|
|
goto done;
|
|
nullfree(memory); memory = NULL;
|
|
}
|
|
done:
|
|
nullfree(memory);
|
|
nclistfree(topvars);
|
|
if(ret != NC_NOERR) {
|
|
fprintf(stderr,"debugcopy: %d %s\n",ret,nc_strerror(ret));
|
|
}
|
|
return THROW(ret);
|
|
}
|
|
|
|
/* Provide a string printer that can be called from gdb */
|
|
void
|
|
NCD4_printstring(const char* s)
|
|
{
|
|
fprintf(stderr,"%s\n",s);
|
|
fflush(stderr);
|
|
}
|